Review

Tip
When creating a function do not forget to declare and define the function. When the Microsoft Visual Studio generates a Linker error, it is not possible to locate the error by double clicking the the error. In most cases, this error is produced because the function declaration or the function definition is incorrect.
Cuando se crea una función no se olvide de declarar y definir la función. Cuando Microsoft Visual Studio genera un error del Enlazador, no es posible ubicar el error al hacer doble clic en el ratón. En la mayoría de los casos, este error es producido porque la declaración de la función o su definición es incorrecta.

Problem 1
Compute the table of variables and the output of the code shown, you can use Microsoft Excel. Verify your results creating a program called Carlos. Do not forget to edit the Carlos.h file.
Calcule la tabla de variables y la salida del código de abajo, usted puede usar Microsoft Excel. Verifique sus resultados creando un programa llamado Carlos. No se olvide de editar el archivo Carlos.h.

Carlos.h
#pragma once //______________________________________ Carlos.h
#include "resource.h"

class Carlos: public Win::Dialog
{
public:
     Carlos()
     {
     }
     ~Carlos()
     {
     }
     double Profit(int ticketCount, double ticketCost);
     . . .
};

Carlos.cpp
void Carlos::Window_Open(Win::Event& e)
{
     double philMoney= 0.0;
     double tessMoney = 0.0;
     philMoney = Profit(10, 55.50);
     tessMoney = Profit(2, 150.50);
     wchar_t text[128];
     _snwprintf_s(text, 128, _TRUNCATE, L"%g, %g", philMoney, tessMoney);
     this->MessageBox(text, L"Program", MB_OK);
}

double Carlos:: Profit(int ticketCount, double ticketCost)
{
     if (ticketCount < 5)
     {
          return ticketCount*ticketCost;
     }
     return ticketCount*ticketCost + 1000.0;
}

CarlosVariableTable

Problem 2
Compute the table of variables and the output of the code shown, you can use Microsoft Excel. Verify your results creating a program called Leon. Do not forget to edit the Leon.h file.
Calcule la tabla de variables y la salida del código de abajo, usted puede usar Microsoft Excel. Verifique sus resultados creando un programa llamado Leon. No se olvide de editar el archivo Leon.h.

Leon.h
#pragma once //______________________________________ Leon.h
#include "resource.h"

class Leon: public Win::Dialog
{
public:
     Leon()
     {
     }
     ~Leon()
     {
     }
     double Profit(int ticketCount, double ticketCost);
     . . .
};

Leon.cpp
void Leon::Window_Open(Win::Event& e)
{
     double philMoney= 0.0;
     double tessMoney = 0.0;
     philMoney = Profit(10, 55.50);
     tessMoney = Profit(2, 150.50);
     wchar_t text[128];
     _snwprintf_s(text, 128, _TRUNCATE, L"%g, %g", philMoney, tessMoney);
     this->MessageBox(text, L"Program", MB_OK);
}

double Leon::Profit(int ticketCount, double ticketCost)
{
     if (ticketCount >= 5)
     {
          return ticketCount*ticketCost + 1000;
     }
     return ticketCount*ticketCost + 100.0;
}

LeonVariableTable

Problem 3
Compute the table of variables and the output of the code shown, you can use Microsoft Excel. Verify your results creating a program called Safety. Do not forget to edit the Safety.h file.
Calcule la tabla de variables y la salida del código de abajo, usted puede usar Microsoft Excel. Verifique sus resultados creando un programa llamado Safety. No se olvide de editar el archivo Safety.h.

Safety.h
#pragma once //______________________________________ Safety.h

class Safety: public Win::Dialog
{
public:
     Safety()
     {
     }
     ~Safety()
     {
     }
     double Procesar(double x);
     . . .
};

Safety.cpp
void Safety::Window_Open(Win::Event& e)
{
     double w = 0.0;
     double y = 10.0;
     w = Procesar(1.0);
     y = Procesar(21.2);
     wstring texto;
     Sys::Format(texto, L"%g - %f", w, y);
     this->MessageBox(texto, L"Hola", MB_OK);
}

double Safety::Procesar(double x)
{
     return x + 1.0;
}

SafetyVariableTable

Problem 4
Compute the table of variables and the output of the code shown, you can use Microsoft Excel. Verify your results creating a program called Theia. Do not forget to edit the Theia.h file.
Calcule la tabla de variables y la salida del código de abajo, usted puede usar Microsoft Excel. Verifique sus resultados creando un programa llamado Theia. No se olvide de editar el archivo Theia.h.

Theia.h
#pragma once //______________________________________ Theia.h
#include "resource.h"

class Theia: public Win::Dialog
{
public:
     Theia()
     {
     }
     ~Theia()
     {
     }
     bool Correcto(double x);
     . . .
};

Theia.cpp
void Theia::Window_Open(Win::Event& e)
{
     wchar_t a[64], b[64];
     int n = 0;
     if (Correcto(5)) n += 2;
     if (true) n -= 5;
     if (false) n = 3 + n;
     _snwprintf_t(a, 64, _TRUNCATE, L"%d", n);
     _snwprintf_t(b, 64, _TRUNCATE, L"%d", 2*n);
     this->MessageBox(a, b, MB_OK);
}

bool Theia::Correcto(double x)
{
     if (x>10) return true;
     return false;
}


TheiaVariableTable

Problem 5
Compute the table of variables and the output of the code shown, you can use Microsoft Excel. Verify your results creating a program called Marte. Do not forget to edit the Marte.h file.
Calcule la tabla de variables y la salida del código de abajo, usted puede usar Microsoft Excel. Verifique sus resultados creando un programa llamado Marte. No se olvide de editar el archivo Marte.h.

Marte.h
#pragma once //______________________________________ Marte.h
#include "resource.h"

class Marte: public Win::Dialog
{
public:
     Marte()
     {
     }
     ~Marte()
     {
     }
     void ShowArea(double w, double h);
     . . .
};

Marte.cpp
void Marte::Window_Open(Win::Event& e)
{
     ShowArea(100, 2.4);
}

void Marte::ShowArea(double w, double h)
{
     wchar_t text[64];
     _snwprintf_s(text, 64, _TRUNCATE, L"%g", w*h);
     this->MessageBox(text, L"Area", MB_OK);
}

MarteVariableTable

Problem 6
Compute the table of variables and the output of the code shown, you can use Microsoft Excel. Verify your results creating a program called Saturn. Do not forget to edit the Saturn.h file.
Calcule la tabla de variables y la salida del código de abajo, usted puede usar Microsoft Excel. Verifique sus resultados creando un programa llamado Saturn. No se olvide de editar el archivo Saturn.h.

Saturn.h
#pragma once //______________________________________ Saturn.h
#include "resource.h"
class Saturn: public Win::Dialog
{
public:
     Saturn()
     {
     }
     ~Saturn()
     {
     }
     double CalculateArea(double w, double h);
     . . .
};

Saturn.cpp
void Saturn::Window_Open(Win::Event& e)
{
     wchar_t text[64];
     _snwprintf_s(text, 64, _TRUNCATE, L"%g", CalculateArea(20, 12.4));
     this->MessageBox(text, L"Area", MB_OK);
}

double Saturn::CalculateArea(double w, double h)
{
     return w*h;
}

SaturnVariableTable

Problem 7
Compute the table of variables and the output of the code shown, you can use Microsoft Excel. Verify your results creating a program called Jupiter. Do not forget to edit the Jupiter.h file.
Calcule la tabla de variables y la salida del código de abajo, usted puede usar Microsoft Excel. Verifique sus resultados creando un programa llamado Jupiter. No se olvide de editar el archivo Jupiter.h.

Jupiter.h
#pragma once //______________________________________ Jupiter.h
#include "resource.h"

class Jupiter: public Win::Dialog
{
public:
     Jupiter()
     {
     }
     ~Jupiter()
     {
     }
     double CalculateTax(double income);
     double CalculateDiscount(double income);
     . . .
};

Jupiter.cpp
void Jupiter::Window_Open(Win::Event& e)
{
     wchar_t text[64];
     double income = 20.0;
     double discount = CalculateDiscount(income);
     _snwprintf_s(text, 64, _TRUNCATE, L"%g", CalculateTax(income));
     this->MessageBox(text, L"TAX", MB_OK);
     _snwprintf_s(text, 64, _TRUNCATE, L"%g", discount);
     this->MessageBox(L"Discount", text, MB_OK);
}

double Jupiter::CalculateDiscount(double income)
{
     double discount = 0.0;
     discount = income +10;
     discount = income *0.1;
     return discount;
}

double Jupiter::CalculateTax(double income)
{
     return income *0.2;
}

JupiterVariableTable

Problem 8
Compute the table of variables and the output of the code shown, you can use Microsoft Excel. Verify your results creating a program called Veronica. Do not forget to edit the Veronica.h file.
Calcule la tabla de variables y la salida del código de abajo, usted puede usar Microsoft Excel. Verifique sus resultados creando un programa llamado Veronica. No se olvide de editar el archivo Veronica.h.

VeronicaVariableTable

Veronica.h
#pragma once //______________________________________ Veronica.h
#include "resource.h"

class Veronica: public Win::Dialog
{
public:
     Veronica()
     {
     }
     ~Veronica()
     {
     }
     double CalculateCorrection(double income);
     double AdjustValue(double income);
     . . .
};

Veronica.cpp
void Veronica::Window_Open(Win::Event& e)
{
     wchar_t text[64];
     double income = 43.0;
     double a = AdjustValue(income);
     double correction= CalculateCorrection(income);
     _snwprintf_s(text, 64, _TRUNCATE, L"%g", correction);
     this->MessageBox(text, L"ADC", MB_OK);
     _snwprintf_s(text, 64, _TRUNCATE, L"%g", a);
     this->MessageBox(L"DEP", text, MB_OK);
}

double Veronica::AdjustValue(double income)
{
     double d = income- 20;
     d = d - income;
     d = income*2;
     return income;
}

double Veronica::CalculateCorrection(double income)
{
     double correction = 3;
     double balance = 4;
     income=income-correction;
     income= income/balance;
     return income;
}


Problem 9
Compute the table of variables and the output of the code shown, you can use Microsoft Excel. Verify your results creating a program called Nube. Do not forget to edit the Nube.h file.
Calcule la tabla de variables y la salida del código de abajo, usted puede usar Microsoft Excel. Verifique sus resultados creando un programa llamado Nube. No se olvide de editar el archivo Nube.h.

NubeVariableTable

Nube.h
#pragma once //______________________________________ Nube.h
#include "resource.h"

class Nube: public Win::Dialog
{
public:
     Nube()
     {
     }
     ~Nube()
     {
     }
     double Adjust(double x);
     . . .
};

Nube.cpp
void Nube::Window_Open(Win::Event& e)
{
     int z = 0;
     wchar_t text[64];
     if (Adjust(3) > 5)
     {
          z = z+2;
     }
     if (Adjust(10)<10) z = z*2;
     _itot_s(z, text, 10); // Convert an integer value to text
     this->MessageBox(text, text, MB_OK);
}

double Nube::Adjust(double x)
{
     double y =x*x+2;
     return y+3;
}


Tip
In the previous example, the function _itot_s (itoa) converts an integer value to text using base 10. In fact, this function allows converting a base 10 number to any base (2, 8, 16, ...).
En el ejemplo previo, la función _itot_s (itoa) convierte un valor entero a texto usando la base 10. De hecho, esta función permite convertir un número base 10 a cualquier base (2, 8, 16, ...).

Problem 10
Compute the table of variables and the output of the code shown, you can use Microsoft Excel. Verify your results creating a program called Blue. Do not forget to edit the Blue.h file.
Calcule la tabla de variables y la salida del código de abajo, usted puede usar Microsoft Excel. Verifique sus resultados creando un programa llamado Blue. No se olvide de editar el archivo Blue.h.

BlueVariableTable

Blue.h
#pragma once //______________________________________ Blue.h
#include "resource.h"

class Blue: public Win::Dialog
{
public:
     Blue()
     {
     }
     ~Blue()
     {
     }
     double Duplicate(double f);
     int Analyze(double a, double b);
     . . .
};

Blue.cpp
void Blue::Window_Open(Win::Event& e)
{
     wchar_t text[64];
     int n = Analyze(10, 12);
     _snwprintf_s(text, 64, _TRUNCATE, L"%g", Duplicate(n));
     this->MessageBox(text, L"Class Activity", MB_OK);
}

int Blue::Analyze(double a, double b)
{
     if (a > b)
          return 5;
     return 10;
}

double Blue::Duplicate(double f)
{
     return 2*f;
}


Problem 11
Compute the table of variables and the output of the code shown, you can use Microsoft Excel. Verify your results creating a program called Dark. Do not forget to edit the Dark.h file.
Calcule la tabla de variables y la salida del código de abajo, usted puede usar Microsoft Excel. Verifique sus resultados creando un programa llamado Dark. No se olvide de editar el archivo Dark.h.

DarkVariableTable

Dark.h
#pragma once //______________________________________ Dark.h
#include "resource.h"

class Dark: public Win::Dialog
{
public:
     Dark()
     {
     }
     ~Dark()
     {
     }
     double Process(double x);
     int Analyze(double a, double b);
     . . .
};

Dark.cpp
void Dark::Window_Open(Win::Event& e)
{
     wchar_t text[64];
     const int n = Analyze(50, 2.22);
     _snwprintf_s(text, 64, _TRUNCATE, L"%g", Process(n));
     this->MessageBox(text, L"Class Activity", MB_OK);
}

int Dark::Analyze(double a, double b)
{
     if (a > b) return 11;
     return 3;
}

double Dark::Process(double x)
{
     double size=10.2;
     double result=3*x+size;
     return result;
}


Problem 12
Compute the table of variables and the output of the code shown, you can use Microsoft Excel. Verify your results creating a program called Liberty. Do not forget to edit the Liberty.h file.
Calcule la tabla de variables y la salida del código de abajo, usted puede usar Microsoft Excel. Verifique sus resultados creando un programa llamado Liberty. No se olvide de editar el archivo Liberty.h.

LibertyVariableTable

Liberty.h
#pragma once //______________________________________ Liberty.h
#include "resource.h"

class Liberty: public Win::Dialog
{
public:
     Liberty()
     {
     }
     ~Liberty()
     {
     }
     double Notify(int type);
     double Control(double input);
     . . .
};

Liberty.cpp
void Liberty::Window_Open(Win::Event& e)
{
     wchar_t text[64];
     int n = 3;
     Control(n);
     _snwprintf_s(text, 64, _TRUNCATE, L"%g", Notify(2*n));
     this->MessageBox(text, L"Class Activity", MB_OK);
}

double Liberty::Notify(int type)
{
     this->MessageBox(L"Notify", L"", MB_OK);
     return type*2.1;
}

double Liberty::Control(double input)
{
     this->MessageBox(L"Control", L"", MB_OK);
     return 0.2*input;
}


Inline functions

It is possible to write both the function definition and the function definition in the header file as illustrated in the following example. In this case, the program runs faster as the compiler inserts (if possible) the function code each time the function is called. This type of functions are called inline functions.
Es posible escribir ambas la definición de la función y su declaración en el archivo de encabezado como se ilustra en el siguiente ejemplo. En este caso, el programa corre más rápido ya que el compilador inserta (si es posible) el código de la función cada vez que se llama la función. Este tipo de funciones son llamadas funciones en línea.

Problem 13
Compute the table of variables and the output of the code shown, you can use Microsoft Excel. Verify your results creating a program called Ice. Do not forget to edit the Ice.h file.
Calcule la tabla de variables y la salida del código de abajo, usted puede usar Microsoft Excel. Verifique sus resultados creando un programa llamado Ice. No se olvide de editar el archivo Ice.h.

IceVariableTable

Ice.h
#pragma once //______________________________________ Ice.h
#include "resource.h"

class Ice: public Win::Dialog
{
public:
     Ice()
     {
     }
     ~Ice()
     {
     }
     int Quintuplicar(int n)
     {
          return 5*n;
     }
     int Samplear(int m)
     {
          int n = 10;
          m = 50*n;
          n = 40;
          return m;
     }
     . . .
};

Ice.cpp
void Ice::Window_Open(Win::Event& e)
{
     wchar_t text[64];
     int n = 2, m = 3;
     _snwprintf_s(text, 64, _TRUNCATE, L"%i, %i", n, m);
     this->MessageBox(text, L"One", MB_OK);
     //
     const int a = Quintuplicar(n);
     const int b = Samplear(m);
     _snwprintf_s(text, 64, _TRUNCATE, L"%i, %i", n, m);
     this->MessageBox(text, L"Two", MB_OK);

     _snwprintf_s(text, 64, _TRUNCATE, L"%i, %i", a, b);
     this->MessageBox(text, L"Three", MB_OK);
}


Tip
The following example uses the function pow(x, y). This function computes the power of x to the y. For example, pow(2, 3) is (2)(2)(2) which is 8.
El siguiente ejemplo usa la función pow(x, y). Esta función calcula la potencia de x a la y. Por ejemplo, pow(2, 3) es (2)(2)(2) lo cual es 8.

Problem 14
Compute the table of variables and the output of the code shown, you can use Microsoft Excel. Verify your results creating a program called Party. Do not forget to edit the Party.h file.
Calcule la tabla de variables y la salida del código de abajo, usted puede usar Microsoft Excel. Verifique sus resultados creando un programa llamado Party. No se olvide de editar el archivo Party.h.

PartyVariableTable

Party.h
#pragma once //______________________________________ Party.h
#include "resource.h"
#define MONDAY 1
#define TUESDAY 2
#define FRIDAY 3

class Party: public Win::Dialog
{
public:
     Party()
     {
     }
     ~Party()
     {
     }
     int Validate(int day);
     . . .
};

Party.cpp
void Party::Window_Open(Win::Event& e)
{
     wchar_t text[64];
     int i = Validate(MONDAY)+Validate(TUESDAY);
     i += Validate(FRIDAY);
     i += Validate(0);
     _snwprintf_s(text, 64, _TRUNCATE, L"%d, %d", i, TUESDAY);
     this->MessageBox(L"", text, MB_OK);
}

int Party::Validate(int x)
{
     return 2*x+1;
}


Problem 15
Compute the table of variables and the output of the code shown, you can use Microsoft Excel. Verify your results creating a program called Camino. Do not forget to edit the Camino.h file.
Calcule la tabla de variables y la salida del código de abajo, usted puede usar Microsoft Excel. Verifique sus resultados creando un programa llamado Camino. No se olvide de editar el archivo Camino.h.

CaminoVariableTable

Camino.h
#pragma once //______________________________________ Camino.h
#include "resource.h"
#define MIN_COUNT 2
#define MAX_COUNT (MIN_COUNT+8)

class Camino: public Win::Dialog
{
public:
     Camino()
     {
     }
     ~Camino()
     {
     }
     double Yen(double x);
     . . .
};

Camino.cpp
void Camino::Window_Open(Win::Event& e)
{
     const int n = MIN_COUNT;
     double yen = Yen(10*MAX_COUNT);
     wchar_t text[64];

     while (yen<52) yen ++;
     _snwprintf_s(text, 64, _TRUNCATE, L"%d = %.2f yen %d", n, yen, MAX_COUNT);
     this->MessageBox(text, text, MB_OK);
}

double Camino::Yen(double x)
{
     wchar_t text[64];
     _snwprintf_s(text, 64, _TRUNCATE, L"%.2f = %.2f", log10(x), x);
     this->MessageBox(text, text, MB_OK);
     return 50.0;
}


Problem 16
Create a project called MyLines to produce the output shown. Create a function called Line as shown below. This function takes an integer value. This integer value is the number of asterisks that will be appended in an output textbox. You may select a mono-space font in the textbox such as: Courier or Courier New.
Cree un proyecto llamado MyLines para producir la salida mostrada. Cree una función llamada Line como se muestra debajo. Esta función toma un entero. Este entero es el número de asteriscos que se dibujan en la caja de texto de salida. Usted puede usar una fuente mono espacio en la caja de texto, tal como: Courier o Courier New.

MyLines.h
class MyLines: public Win::Dialog
{
public:
     MyLines ()
     {
     }
     ~ MyLines ()
     {
     }
     void Line(int asterisk);
     . . .
};

MyLines.cpp

void MyLines::Window_Open(Win::Event& e)
{
     Line(3);
     Line(4);
     Line(3);
     Line(5);
     Line(2);
}

void MyLines::Line(int asterisk)
{
     . . .
}

MyLines

Problem 17
Create a project called VariasLineas so that when the user presses the OK button, the program writes the number of lines specified (using four asterisks for each line). Copy and paste the function Line from the previous problem.
Cree un proyecto llamada VariasLineas de tal forma que cuando el usuario presione el botón de OK, el programa escriba el número de líneas especificado (usando cuatro asteriscos por cada línea). Copie y pegue la función Line del problema anterior.

VariasLineas3

VariasLineas5

VariasLineas9

Problem 18
Write a program called Tree (using the function Line previously implemented) to produce the output implemented when the button OK is pressed.
Escriba un programa llamada Tree (usando la función Line previamente implementada) para producir la salida implementada cuando se presiona el botón de OK.

Tree

Problem 19
Write a program called Cone (using the function Line previously implemented) to produce the output implemented when the button OK is pressed.
Escriba un programa llamada Cone (usando la función Line previamente implementada) para producir la salida implementada cuando se presiona el botón de OK.

Cone

Problem 20
Write a program called Piramid (using the function Line previously implemented) to produce the output implemented when the button OK is pressed.
Escriba un programa llamada Piramid (usando la función Line previamente implementada) para producir la salida implementada cuando se presiona el botón de OK.

Piramid

Problem 21
Create a project called SpaceLine to produce the output shown. Create a function called Line as shown below. This function takes two integer values. The first integer value is the number of spaces and the second one is the number of asterisks that will be appended in an output textbox. You may select a mono-space font in the textbox such as: Courier or Courier New.
Cree un proyecto llamado SpaceLine para producir la salida mostrada. Cree una función llamada Line como se muestra debajo. Esta función toma dos enteros. El primer entero es el número de espacios y el segundo es el número de asteriscos que se dibujan en la caja de texto de salida. Usted puede usar una fuente mono espacio en la caja de texto, tal como: Courier o Courier New.

SpaceLine.h
class SpaceLine: public Win::Dialog
{
public:
     SpaceLine ()
     {
     }
     ~ SpaceLine ()
     {
     }
     void Line(int spaces, int asterisks);
     . . .
};

SpaceLine.cpp

void SpaceLine::Window_Open(Win::Event& e)
{
     Line(0, 3);
     Line(2, 7);
     Line(2, 5);
     Line(3, 2);
}

void SpaceLine::Line(int spaces, int asterisks)
{
     . . .
}

SpaceLine

Problem 22
Write a program called Arrow (using the function Line previously implemented) to produce the output implemented when the button OK is pressed.
Escriba un programa llamada Arrow (usando la función Line previamente implementada) para producir la salida implementada cuando se presiona el botón de OK.

Arrow

Problem 23
Write a program called ArrowLeft (using the function Line previously implemented) to produce the output implemented when the button OK is pressed.
Escriba un programa llamada ArrowLeft (usando la función Line previamente implementada) para producir la salida implementada cuando se presiona el botón de OK.

ArrowLeft

Problem 24
Write a program called ArrowRight (using the function Line previously implemented) to produce the output implemented when the button OK is pressed.
Escriba un programa llamada ArrowRight (usando la función Line previamente implementada) para producir la salida implementada cuando se presiona el botón de OK.

ArrowRight

Problem 25
Write a program called Primo to indicate whether a number is prime or not. Implement your program by creating the function IsPrime as shown below.
Escriba un programa llamado primo para indicar si un número es primo o no. Implemente su programa creando una función llamada IsPrime como muestra debajo.

Primo.cpp
void Primo::Window_Open(Win::Event& e)
{
}

bool Primo::IsPrime(int number)
{
     // Write your function here
}

void Primo::btCheck_Click(Win::Event& e)
{
     if (tbxInput.Text.length() > 0)
     {
          const int number = this->tbxInput.IntValue;
          if (IsPrime(number) == true)
          {
               this->tbxInput.ShowBalloonTip(L"Result", L"The number is prime", TTI_INFO);
          }
          else
          {
               this->tbxInput.ShowBalloonTip(L"Result", L"The number is NOT prime", TTI_WARNING);
          }
     }
}

PrimoFalse

PrimoTrue

Hint
If the number is equal to or less than one, the number is prime. If the number is even, the number is not prime. In all remaining cases, the number is divided by 3, 5, 7, ..., until reach the squared root of the number, if at any moment the division has rest of 0, the number is not prime.
Si el número es menor o igual a uno, el número no es primo. Si el número es par, el número no es primo. En todos los demás casos se divide el número entre 3, 5, 7, ... , hasta llegar a la raíz cuadrada del número, si en cualquier momento el residuo de la división es cero, el número no es primo.

20      As 20 is an even number, 20 is not prime (como el 20 es un número par, el 20 no es primo)  

19      The squared root of 19 is 4.35 ( la raíz cuadrada de 19 es 4.35)  
      19/3 = 6, rest = 1 (sobra 1)
     19/5 = 3, rest = 4 (sobra 4)
      5 is bigger than 4.35 (5 es mayor que 4.35)
     Therefore, 19 is a prime number (por lo tanto, el 19 es un número primo)

15      The squared root of 15 is 3.87 ( la raíz cuadrada de 15 es 3.87)  
      15/3 = 5, rest = 0 (sobra 0)
     Therefore, 15 is not a prime number (por lo tanto, el 15 no es un número primo)

47      The squared root of 47 is 6.85 ( la raíz cuadrada de 47 es 6.87)  
      47/3 = 15, rest = 2 (sobra 2)
     47/5 = 9, rest = 2 (sobra 2)
     7 is bigger than 6.85 (7 es mayor que 6.85)
     Therefore, 47 is a prime number (por lo tanto, el 47 es un número primo)

Problem 26
Compute the table of variables and the output of the code shown. Suppose there is a textbox called tbx1 with the property of multiline. Create a program called Orange to test your result.
Calcule la tabla de variables y la salida del código de abajo. Suponga que hay una caja de texto llamada tbx1 con la propiedad de multilínea. Cree un programa llamado Orange para probar sus resultados.

OrangeVariableTable

Orange.h
//______________________________________ Orange.h
#pragma once
#include "resource.h"
#define MAX_VAL 1
#define MIN_VAL -2
class Orange: public Win::Dialog
{
public:
     Orange()
     {
     }
     ~Orange()
     {
     }
     bool IsValid(double x);
     int Deduct(double x);
     . . .
};

Orange.cpp
void Orange::Window_Open(Win::Event& e)
{
     int i= 0, n = Deduct(7.0);
     if (IsValid(25.0) == true)
     {
          for(i = MIN_VAL; i<MAX_VAL; i++) n++;
     }
     else
     {
          for(i = MAX_VAL; i<MIN_VAL; i--) n++;
     }
     tbx1.IntValue = n;
}

bool Orange::IsValid(double x)
{
     return (x>10);
}

int Orange::Deduct(double x)
{
     int n = (int)x;
     if (x<2) n++;
     else n--;
     return n;
}


Problem 27
Compute the table of variables and the output of the code shown. Suppose there is a textbox called tbx1 with the property of multiline. Create a program called Manzana to test your result.
Calcule la tabla de variables y la salida del código de abajo. Suponga que hay una caja de texto llamada tbx1 con la propiedad de multilínea. Cree un programa llamado Manzana para probar sus resultados.

Manzana.h
//______________________________________ Manzana.h
#pragma once
#include "resource.h"
class Manzana: public Win::Dialog
{
public:
     Manzana()
     {
     }
     ~Manzana()
     {
     }
     bool IsValid(double x);

     . . .
};

Manzana.cpp
void Manzana::Window_Open(Win::Event& e)
{     
     wchar_t text[32];
     for (int i = 0; i < 8; i++)
     {
          if (IsValid((double)i) == true)
          {
               _snwprintf_t(text, 32, _TRUNCATE, L"%d\r\n", 2*i);
               tbx1.Text += text;
          }
          else
          {
               _snwprintf_t(text, 32, _TRUNCATE, L"%d\r\n", 3*i);
               tbx1.Text += text;
          }
     }
}

bool Manzana::IsValid(double x)
{
     return (x>10);
}


Problem 28
Write a program called Series to compute the series described in the table. To create the event, double click in the textbox for n and in the Events tab check the event Change as shown in the figure.
Escriba un programa llamado Series para calcular las series descritas en la tabla. Para crear el evento, haga doble clic en la caja de texto para n y en la pestaña de Eventos marque el evento Change como se muestra en la figura.

n    x    y  
021
123
243
345
465
567
687
789
. . .. . .. . .

Series0

Series1

Series2

Series.h
#pragma once //______________________________________ Series.h
#include "resource.h"

class Series: public Win::Dialog
{
public:
     Series()
     {
     }
     ~Series()
     {
     }
     int ComputeX(int n);
     int ComputeY(int n);
protected:
     . . .
};

Series.cpp
void Series::Window_Open(Win::Event& e)
{
}

void Series::tbxN_Change(Win::Event& e)
{
     const int n = tbxN.IntValue;
     tbxX.IntValue = ComputeX(n);
     tbxY.IntValue = ComputeY(n);
}

int Series::ComputeX(int n)
{
}

int Series::ComputeY(int n)
{
}

SeriesNChange

Problem 29
Write a program called Wallis to compute the value of π using Walli's product. Create a function called GetTerm(int n) as shown;
Escriba un programa llamado Wallis para calcular el valor de π usando el producto de Wallis. Cree una función llamada GetTerm(int n) como se muestra.

Wallis.h
#pragma once //______________________________________ Wallis.h
#include "resource.h"

class Wallis: public Win::Dialog
{
public:
     Wallis()
     {
     }
     ~Wallis()
     {
     }
     double GetTerm(int n);
     double GetNumerator(int n);
     double GetDenominator(int n);
protected:
     . . .
};

Wallis.cpp
void Wallis::Window_Open(Win::Event& e)
{
}

void Wallis::btCalculate_Click(Win::Event& e)
{
     . . .
     for(int n = 0; n<count; n++)
     {
          product *= GetTerm(n);
     }
     . . .
}

double Wallis::GetTerm(int n)
{
}

double Wallis::GetNumerator(int n)
{
}

double Wallis::GetDenominator(int n)
{
}

Wallis

WallisTable

Problem 30
Create a program called BaseConverter to convert a number from base 10 to any base less than 9 as shown below. Do not use the function itoa or equivalent in this problem.
Cree un programa llamado BaseConverter para convertir un número de base 10 a cualquier base que sea menor a 9 como se muestra debajo. No use la función itoa o equivalente en este problema.

Tip
To reverse a string or any other data container, you may use the function std::reverse as shown in the example below. The code below is an generic example how to use std::reverse.
Para invertir una cadena de texto o los datos de un contenedor de la STL, usted puede usar la función std::reverse como se ilustra debajo. El código de bajo es un ejemplo genérico de cómo usar std::reverse.

Reverse.cpp
void Reverse::Window_Open(Win::Event& e)
{
     wstring a(L"Abcdef");
     std::reverse(a.begin(), a.end());
}


BaseConverter1

BaseConverter11

BaseConverter542

BaseConverter22564

BaseConverter.h
#pragma once //______________________________________ BaseConverter.h
#include "resource.h"

class BaseConverter: public Win::Dialog
{
public:
     BaseConverter()
     {
     }
     ~BaseConverter()
     {
     }
     wstring Convert(int input, int base);
protected:
     . . .
};

BaseConverter.cpp
void BaseConverter::Window_Open(Win::Event& e)
{
}

void BaseConverter::btConvert_Click(Win::Event& e)
{
     const int input = tbxInput.IntValue;
     const int base = tbxBase.IntValue;
     tbxOutput.Text = Convert(input, base);
}

wstring BaseConverter::Convert(int input, int base)
{
     int digit;
     wstring output;
     . . .
     return output;
}


Problem 31
Create a program called MyDigits to separate the digits of an integer number as shown below. You may use the "Change" event in the input textbox.
Cree un programa llamado MyDigits para separar los dígitos de un número entero como se muestra debajo. Usted puede usar el evento de "Change" en la caja de texto de entrada.

MyDigitsRun1

MyDigitsRun2

© Copyright 2000-2021 Wintempla selo. All Rights Reserved. Jul 22 2021. Home