Another lottery draw simulation (C++ Builder)

file p_Lotto.h

#ifndef p_LottoH

#define p_LottoH

//---------------------------------------------------------------------------

#include <System.Classes.hpp>

#include <Vcl.Controls.hpp>

#include <Vcl.StdCtrls.hpp>

#include <Vcl.Forms.hpp>

#include <Vcl.ExtCtrls.hpp>

//---------------------------------------------------------------------------

class TForm1 : public TForm

{

__published: // IDE-managed Components

TLabel *Label1;

TTimer *Timer1;

TButton *Button1;

TButton *Button2;

TEdit *Edit1;

TEdit *Edit2;

TEdit *Edit3;

TEdit *Edit4;

TEdit *Edit5;

TListBox *ListBox1;

void __fastcall Button2Click(TObject *Sender);

void __fastcall Button1Click(TObject *Sender);

void __fastcall Timer1Timer(TObject *Sender);

private: // User declarations

   void __fastcall my_Sort(int* tab, int s);

   int base[5];

   int temp[42];

   int rand_Lotto[1000][5];

   int temp_Simulations[1000][42];

   void __fastcall init_Base();

   void __fastcall init_Simulations();

   int sum_5,sum_4,sum_3,sum_2,sum_1,sum_0;

   bool __fastcall is_5(int* base, int* temp);

   bool __fastcall is_4(int* base, int* temp);

   bool __fastcall is_3(int* base, int* temp);

   bool __fastcall is_2(int* base, int* temp);

   bool __fastcall is_1(int* base, int* temp);

   bool __fastcall is_0(int* base, int* temp);

public: // User declarations

__fastcall TForm1(TComponent* Owner);

};

//---------------------------------------------------------------------------

extern PACKAGE TForm1 *Form1;

//---------------------------------------------------------------------------

#endif

file p_Lotto.cpp

 #include <vcl.h>

#include <stdlib.h>

#include <time.h>

#pragma hdrstop

#include "p_Lotto.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

//---------------------------------------------------------------------------

__fastcall TForm1::TForm1(TComponent* Owner)

: TForm(Owner)

{

 srand(time(NULL));

 Button1->Caption="&RUN";

 Button2->Caption="&CLOSE";

 UnicodeString c="";

 Edit1->Text=c;

 Edit2->Text=c;

 Edit3->Text=c;

 Edit4->Text=c;

 Edit5->Text=c;

}

void __fastcall TForm1::my_Sort(int* tab, int s)

{

int i,j,k;

for(i=1;i<s;i++)

{

j=i;

k=tab[j];

while((j>0) && (tab[j-1]>k))

{

tab[j]=tab[j-1];

j--;

}

tab[j]=k;

}

}

void __fastcall TForm1::init_Base()

{

int i,j;

for(i=0;i<42;i++)

temp[i]=0;

i=0;

do

{

do{

j=rand()%42;

}while(temp[j]!=0);

temp[j]=1;

base[i]=j+1;

++i;

}while(i<5);

my_Sort(base,5);

}

void __fastcall TForm1::init_Simulations()

{

int i,j,k,l;

for(i=0;i<1000;i++)

{

for(j=0;j<42;j++)

{

temp_Simulations[i][j]=0;

}

}

k=0;

do

{

  j=0;

   do

   {

   do

   {

l=rand()%42;

   }while(temp_Simulations[k][l]!=0);

   temp_Simulations[k][l]=1;

   rand_Lotto[k][j]=l+1;

   ++j;

  }while(j<5);

++k;

}while(k<1000);

}

bool __fastcall TForm1::is_5(int* base, int* temp)

{

int i,j,sum;

sum=0;

for(i=0;i<5;i++)

{

for(j=0;j<5;j++)

{

if(base[i]==temp[j])

++sum;

}

}

if(sum==5)

return true;

else

return false;

}

bool __fastcall TForm1::is_4(int* base, int* temp)

{

 int i,j,sum;

sum=0;

for(i=0;i<5;i++)

{

for(j=0;j<5;j++)

{

if(base[i]==temp[j])

++sum;

}

}

if(sum==4)

return true;

else

return false;

}

bool __fastcall TForm1::is_3(int* base, int* temp)

{

 int i,j,sum;

sum=0;

for(i=0;i<5;i++)

{

for(j=0;j<5;j++)

{

if(base[i]==temp[j])

++sum;

}

}

if(sum==3)

return true;

else

return false;

}

bool __fastcall TForm1::is_2(int* base, int* temp)

{

 int i,j,sum;

sum=0;

for(i=0;i<5;i++)

{

for(j=0;j<5;j++)

{

if(base[i]==temp[j])

++sum;

}

}

if(sum==2)

return true;

else

return false;

}

bool __fastcall TForm1::is_1(int* base, int* temp)

{

 int i,j,sum;

sum=0;

for(i=0;i<5;i++)

{

for(j=0;j<5;j++)

{

if(base[i]==temp[j])

++sum;

}

}

if(sum==1)

return true;

else

return false;

}

bool __fastcall TForm1::is_0(int* base, int* temp)

{

 int i,j,sum;

sum=0;

for(i=0;i<5;i++)

{

for(j=0;j<5;j++)

{

if(base[i]==temp[j])

++sum;

}

}

if(sum==0)

return true;

else

return false;

}

//---------------------------------------------------------------------------

//---------------------------------------------------------------------------

void __fastcall TForm1::Button2Click(TObject *Sender)

{

 Close();

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)

{

 int i,j;

 init_Base();

 init_Simulations();

 sum_5=sum_4=sum_3=sum_2=sum_1=sum_0=0;

 Edit1->Text=IntToStr(base[0]);

 Edit2->Text=IntToStr(base[1]);

 Edit3->Text=IntToStr(base[2]);

 Edit4->Text=IntToStr(base[3]);

 Edit5->Text=IntToStr(base[4]);

 ListBox1->Items->Clear();

 ListBox1->Items->Add("After 1000 draws");

 for(i=0;i<1000;i++)

 {

if(is_5(base,rand_Lotto[i]))

++sum_5;

if(is_4(base,rand_Lotto[i]))

++sum_4;

if(is_3(base,rand_Lotto[i]))

++sum_3;

if(is_2(base,rand_Lotto[i]))

++sum_2;

if(is_1(base,rand_Lotto[i]))

++sum_1;

if(is_0(base,rand_Lotto[i]))

++sum_0;

}

 ListBox1->Items->Add("5/5 ="+IntToStr(sum_5));

 ListBox1->Items->Add("5/4 ="+IntToStr(sum_4));

 ListBox1->Items->Add("5/3 ="+IntToStr(sum_3));

 ListBox1->Items->Add("5/2 ="+IntToStr(sum_2));

 ListBox1->Items->Add("5/1 ="+IntToStr(sum_1));

 ListBox1->Items->Add("5/0 ="+IntToStr(sum_0));

}

//---------------------------------------------------------------------------

//---------------------------------------------------------------------------

void __fastcall TForm1::Timer1Timer(TObject *Sender)

{

 UnicodeString t,d;

 t=TimeToStr(Time());

 d=DateToStr(Date());

 Label1->Caption=d+"  "+t;

}

struct my_Queue - gcc

 

#include <stdio.h>
#include <stdlib.h>
#define max_Size 1000

int* main_Tab;
int is_First(int value)
{
    int i,sum;
    sum=0;
    for(i=1;i<value+1;i++)
    if(value%i==0)
     ++sum;
    if(sum==2)
     return 1;
    else
     return 0;
}
void init_Tab()
{
    int i,j;
    main_Tab=malloc(sizeof(int)*max_Size);
    i=0;
    j=1;
    do
    {
        if(is_First(j))
        {
            main_Tab[i]=j;
            ++i;
        }
        ++j;
    }while(i<max_Size);
}
void destroy_Tab()
{
    free(main_Tab);
}

typedef struct 
{
    int y1;
    int y2;
    int* value;
}my_Queue;
void start_Queue(my_Queue* temp_Queue)
{
    temp_Queue->y1=0;
    temp_Queue->y2=0;
    temp_Queue->value=(int*)malloc(max_Size*sizeof(int));
}
int show_Size(my_Queue* temp_Queue)
{
    int temp_Value;
    temp_Value=temp_Queue->y2-temp_Queue->y1;
    return temp_Value;
}
void destroy_Queue(my_Queue* temp_Queue)
{
    free(temp_Queue->value);
}
void add_Queue(my_Queue* temp_Queue, int temp_Value)
{
    temp_Queue->value[temp_Queue->y2]=temp_Value;
    temp_Queue->y2++;
}
int write_values_Queue(my_Queue* temp_Queue)
{
    int temp_Value;
    temp_Value=temp_Queue->value[temp_Queue->y1];
    temp_Queue->y1++;
    return temp_Value;
}

int main(int argc, char **argv)
{
    int i;
    init_Tab();
    my_Queue* test_Queue=(my_Queue*)malloc(sizeof(my_Queue));
    start_Queue(test_Queue);
    for(i=0;i<max_Size;i++)
    {
        add_Queue(test_Queue,main_Tab[i]);
    }
    for(i=0;i<max_Size;i++)
    {
        printf("%d )  %d\n",i+1,write_values_Queue(test_Queue));
    }
    destroy_Queue(test_Queue);
    free(test_Queue);
    destroy_Tab();
    return 0;
}

Opening a file from Libre Office in the StringGrid component - C++ Builder

 File Libre Office -  STAFF.ods 

Application.exe

Project.cpp

#include <vcl.h>

#include <utilcls.h>

#pragma hdrstop

#include "Unit1.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

//---------------------------------------------------------------------------

__fastcall TForm1::TForm1(TComponent* Owner)

: TForm(Owner)

{

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)

{

String my_Path="C:\\Users\\admin\\Documents\\STAFF.ods";

Variant mSe, mDe, mDo, mSh, mCe;

Variant mArgs = VarArrayCreate(OPENARRAY(int, (0, -1)), varVariant);

String f_URL = "file:///" + StringReplace(my_Path, "\\", "/", TReplaceFlags() << rfReplaceAll);

   try {

mSe = Variant::CreateObject("com.sun.star.ServiceManager");

mDe = mSe.OleFunction("createInstance", "com.sun.star.frame.Desktop");

mDo = mDe.OleFunction("loadComponentFromURL", f_URL, "_blank", 0, mArgs);

if (mDo.IsEmpty()) {

ShowMessage("I can't open the file");

return;

}

Variant vSheets = mDo.OleFunction("getSheets");

mSh = vSheets.OleFunction("getByIndex", 0);

int maxCols = 3;

int maxRows = 9;

StringGrid1->ColCount = maxCols;

StringGrid1->RowCount = maxRows;

for (int r = 0; r < maxRows; r++) {

for (int c = 0; c < maxCols; c++) {

mCe=mSh.OleFunction("getCellByPosition", c, r);

StringGrid1->Cells[c][r] = mCe.OlePropertyGet("String");

}

}

ShowMessage("SUCCESS!");

}

catch (Exception &e) {

ShowMessage("Error: " + e.Message);

}

}

Moon phases - C++ Builder

 

private: // User declarations

    double __fastcall get_moon_phase(int year, int month, int day);

    void __fastcall DrawMoon(TCanvas *Canvas, int x, int y, int radius, double phase);

#include <vcl.h>

#include <System.SysUtils.hpp>

#include <time.h>

#include <math.h>

#pragma hdrstop

#include "p_Moon.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

//---------------------------------------------------------------------------

__fastcall TForm1::TForm1(TComponent* Owner)

: TForm(Owner)

{

}

double __fastcall TForm1::get_moon_phase(int year, int month, int day)

{

if (month < 3) {

year--;

month += 12;

}

int A = year / 100;

int B = A / 4;

int C = 2 - A + B;

int E = (int)(365.25 * (year + 4716));

int F = (int)(30.6001 * (month + 1));

double jd = C + day + E + F - 1524.5;

double known_new_moon = 2451550.26;

double lunar_cycle = 29.530588853;

double days_since_new = jd - known_new_moon;

double cycles = days_since_new / lunar_cycle;

double phase = cycles - (long)cycles;

if (phase < 0) phase += 1;

return phase;

}

void __fastcall TForm1::DrawMoon(TCanvas *Canvas, int x, int y, int radius, double phase)

{

Canvas->Pen->Style = psSolid;

Canvas->Pen->Color = clGray;

Canvas->Brush->Color = clBlack;

Canvas->Brush->Style = bsSolid;

Canvas->Ellipse(x - radius, y - radius, x + radius, y + radius);

Canvas->Pen->Color = clYellow;

Canvas->Brush->Color = clYellow;

for (int i = -radius; i <= radius; i++) {

double w = sqrt((double)radius * radius - (double)i * i);

double terminatorX = w * cos(2.0 * M_PI * phase);

int xStart, xEnd;

if (phase <= 0.5) {

xStart = (int)(x + terminatorX);

xEnd   = (int)(x + w);

} else {

xStart = (int)(x - w);

xEnd   = (int)(x + terminatorX);

}

if (xStart < xEnd) {

Canvas->MoveTo(xStart, y + i);

Canvas->LineTo(xEnd, y + i);

}

}

Canvas->Brush->Style = bsClear;

Canvas->Pen->Color = clGray;

Canvas->Ellipse(x - radius, y - radius, x + radius, y + radius);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Timer1Timer(TObject *Sender)

{

  Label1->Caption=DateToStr(Date());

  Label4->Caption=TimeToStr(Time());

}

//---------------------------------------------------------------------------

void __fastcall TForm1::FormCreate(TObject *Sender)

{

 Button1->Caption="&Start";

 Button2->Caption="&Close";

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button2Click(TObject *Sender)

{

 Close();

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)

{

 int y,d,m;

 double phase, illumination;

 Word year,month,day;

 TDateTime today=Date();

 DecodeDate(today,year,month,day);

 y=(int)year;

 d=(int)day;

 m=(int)month;

 phase=get_moon_phase(y, m, d);

 illumination = (1 - cos(2 * M_PI * phase)) / 2 * 100;

 Label2->Caption="Lighting: "+FloatToStrF(illumination,ffGeneral,4,2)+"%";

 DrawMoon(Canvas, 200, 200, 100, phase);

}

Valarray - C++ Builder

 

    

private: // User declarations

float tab[5];

#include <vcl.h>

#include <valarray>

#include <stdlib.h>

#include <time.h>

#pragma hdrstop

#include "p_aarray.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

//---------------------------------------------------------------------------

__fastcall TForm1::TForm1(TComponent* Owner)

: TForm(Owner)

{

 srand(time(NULL));

}

//---------------------------------------------------------------------------

void __fastcall TForm1::FormCreate(TObject *Sender)

{

 StringGrid1->ColCount=5;

 StringGrid1->RowCount=1;

 StringGrid1->FixedCols=0;

 StringGrid1->FixedRows=0;

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)

{

 int i;

 const float a=50.00;

 for(i=0;i<5;i++)

 {

tab[i]=(1+rand()%100)/a;

StringGrid1->Cells[i][0]=FloatToStrF(tab[i],ffGeneral,4,4);

 }

 std::valarray<float> bb {tab[0],tab[1], tab[2], tab[3], tab[4]};

 Label1->Caption="sum() = "+FloatToStrF(bb.sum(),ffGeneral,4,4);

 Label2->Caption="min() = "+FloatToStrF(bb.min(),ffGeneral,4,4);

 Label3->Caption="max() = "+FloatToStrF(bb.max(),ffGeneral,4,4);

 std::valarray<float> temp_Sqrt=sqrt(bb);

 Label4->Caption="sqrt() = "+FloatToStrF(temp_Sqrt[0],ffGeneral,4,4)+"  "+

 FloatToStrF(temp_Sqrt[1],ffGeneral,4,4)+"  "+

 FloatToStrF(temp_Sqrt[2],ffGeneral,4,4)+"  "+

 FloatToStrF(temp_Sqrt[3],ffGeneral,4,4)+"  "+

 FloatToStrF(temp_Sqrt[4],ffGeneral,4,4)+"  ";

}

Fonts in Windows (C++ Builder)

private: // User declarations

UnicodeString text;

void __fastcall Begin();

void __fastcall TForm1::Timer1Timer(TObject *Sender)

{

 UnicodeString d,t;

 d=DateToStr(Date());

 t=TimeToStr(Time());

 text=d+"      "+t;

 Label1->Caption=text;

}

void __fastcall TForm1::Begin()

{

 ListBox1->Items->Clear();

 ComboBox1->Items->Clear();

 ComboBox1->Items->Assign(Screen->Fonts);

 ComboBox1->Text="";

 ListBox1->Items->Assign(Screen->Fonts);

 Label2->Caption="All fonts in Windows (testing ComboBox) ";

 Label3->Caption="All fonts in Windows (testing ListBox) ";

}

//---------------------------------------------------------------------------

void __fastcall TForm1::FormCreate(TObject *Sender)

{

 Begin();

}

//---------------------------------------------------------------------------

void __fastcall TForm1::ComboBox1Change(TObject *Sender)

{

  Label2->Font->Name=ComboBox1->Text;

}

//---------------------------------------------------------------------------

void __fastcall TForm1::ListBox1Click(TObject *Sender)

{

 Label3->Font->Name=ListBox1->Items->Strings[ListBox1->ItemIndex];

}

 

Getting data from a file into a StringGrid - C++ Builder

 

file military_power.txt

France 228656 195770 423 149 60 1203 120 1

USA 1430000 850880 8325 1934 1330 13683 473 10

China 2285000 2300000 9150 1710 1770 2788 520 1

India 1325000 2143000 3569 290 292 1785 184 2

UK 205330 182000 407 89 56 908 66 1

Japan 247746 57900 767 196 99 1595 131 1

Russia 766000 2485000 15500 5990 3781 3082 352 1

Unit1.cpp

__fastcall TForm1::TForm1(TComponent* Owner)

: TForm(Owner)

{

}

//---------------------------------------------------------------------------

struct armed_Forces

{

char country[64];

int so;

int re;

int ta;

int ar;

int mi;

int mt;

int mn;

int ac;

};

void __fastcall TForm1::FormCreate(TObject *Sender)

{

 Button1->Caption="&OPEN";

 Button2->Caption="&CLOSE";

 UnicodeString Date[9]={"country","soldiers","reserve","tanks","artillery",

 "missyle_systems", "military_aviation","military_navy","aircraft_carriers"};

 for(int i=0;i<9;i++)

 {

StringGrid1->Cells[i][0]=Date[i];

 }

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button2Click(TObject *Sender)

{

 Close();

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)

{

 FILE* fp;

 int i;

 if((fp=fopen("military_power.txt","r"))==NULL)

 {

ShowMessage("Error. I can't open the file!");

 }

 else

 {

  struct armed_Forces a_F[7];

   for(i=0;i<7;i++)

   {

   fscanf(fp,"%s %d %d %d %d %d %d %d %d\n",a_F[i].country,&a_F[i].so,&a_F[i].re,

   &a_F[i].ta,&a_F[i].ar,&a_F[i].mi,&a_F[i].mt,&a_F[i].mn,&a_F[i].ac);

   }

  for(i=0;i<7;i++)

   {

   StringGrid1->Cells[0][i+1]=UnicodeString(a_F[i].country);

   StringGrid1->Cells[1][i+1]=IntToStr(a_F[i].so);

   StringGrid1->Cells[2][i+1]=IntToStr(a_F[i].re);

   StringGrid1->Cells[3][i+1]=IntToStr(a_F[i].ta);

   StringGrid1->Cells[4][i+1]=IntToStr(a_F[i].ar);

   StringGrid1->Cells[5][i+1]=IntToStr(a_F[i].mi);

   StringGrid1->Cells[6][i+1]=IntToStr(a_F[i].mt);

   StringGrid1->Cells[7][i+1]=IntToStr(a_F[i].mn);

   StringGrid1->Cells[8][i+1]=IntToStr(a_F[i].ac);

   }

 }

}