devair1010

@matheus.Matta     para essas libs "HEADER"  funcionar elas precisam  estar na mesma pasta onde você coloca esse código da função main , seu código principaL , 

aqui a função     "main.c"

#define     _WIN32_WINNT 0x600
#define     _h GetStdHandle(STD_OUTPUT_HANDLE)
#include    <stdio.h>
#include    <conio.h>
#include    <iso646.h>
#include    <stdlib.h>
#include    <string.h>
#include    <windows.h>
#include    <math.h>
#include    <time.h>
#include    <locale.h>
#include    <dirent.h>
#include    "libbmp.h"
#include    "imghelpers.h"
#include    "libbmp.c"
#include    "imghelpers.c"
int main    ( int argc, char *argv[]                         )
{
    int letra,fundo;
    CONSOLE_SCREEN_BUFFER_INFO _c                            ;
    if( GetConsoleScreenBufferInfo     ( _h, & _c )          )
    {
        letra = (   _c.wAttributes & 0xFF )            & 0x0F;
        fundo = ( ( _c.wAttributes & 0xFF ) >> 4    )  & 0x0F;
    }
    SetConsoleTextAttribute( _h, 11 +       ( 0 << 4 )      );
    setlocale(LC_ALL,"");
    ///-------------------------------------------------------

    DIR *dp;
    struct dirent *ep;
    char filename[100];
    int firstFile = 0;                   // Variável de controle
    const char directory[] = "uploads/"; // Caminho do diretório
    int ret = 0;
    dp = opendir(directory);
    if (dp != NULL)
    {
        while ((ep = readdir(dp)))
        {
            if (ep->d_type == DT_REG && !firstFile)
            {
                snprintf(filename, sizeof(filename), "%s%s", directory, ep->d_name);
                firstFile = 1;
            }
        }
        (void)closedir(dp);
    }
    else
    {
        SetConsoleTextAttribute( _h, 15 +  ( 12 << 4 )  );
        perror("\n  Não foi possível abrir o diretório 'uploads'.  !  ");
        ret = 1;
    }
    if( ! ret )
    {
        // Utilize apenas imagens .bmp com o formato 24 (true color)
        // converta em: https://online-converting.com/image/convert2bmp/
        bmp_img img;
        printf("\n");
        IMG_TAM t = pegarTamanho(filename);
        int l = t.qtdLinhas, c = t.qtdColunas;
        int R[l][c];
        int G[l][c];
        int B[l][c];
        carregaImagem(t, R, G, B, filename);
        // manipule sua imagem aqui.
        for (int i = 0; i < l; i++)
        {
            for (int j = 0; j < c; j++)
            {
                R[i][j] = G[i][j];
                B[i][j] = R[i][j];
                G[i][j] = B[i][j];
            }
        }
        salvaImagem(t, R, G, B, filename);
        mostrarNoReplit(filename);
    }
    ///------------------------------------------------------
    SetConsoleTextAttribute( _h, letra +  ( fundo << 4 )  );
    printf("\n\n\n");
    return    ret                                          ;
}

o código do "HEADER"   libbmp.h  :

#ifndef LIBBMP_H_INCLUDED
#define LIBBMP_H_INCLUDED

  #include <stdio.h>

#define BMP_MAGIC 19778
#define BMP_GET_PADDING(a) ((a) % 4)
#define BMP_PIXEL(r, g, b) ((bmp_pixel){(b), (g), (r)})
enum bmp_error
{
  BMP_FILE_NOT_OPENED = -4,
  BMP_HEADER_NOT_INITIALIZED,
  BMP_INVALID_FILE,
  BMP_ERROR,
  BMP_OK = 0
};
typedef struct ax as;
typedef struct _bmp_header
{
  unsigned int bfSize;
  unsigned int bfReserved;
  unsigned int bfOffBits;
  unsigned int biSize;
  int biWidth;
  int biHeight;
  unsigned short biPlanes;
  unsigned short biBitCount;
  unsigned int biCompression;
  unsigned int biSizeImage;
  int biXPelsPerMeter;
  int biYPelsPerMeter;
  unsigned int biClrUsed;
  unsigned int biClrImportant;
} bmp_header;
typedef struct _bmp_pixel
{
  unsigned char blue;
  unsigned char green;
  unsigned char red;
} bmp_pixel;

typedef struct _bmp_img
{
  bmp_header* img_header;
  bmp_pixel **img_pixels;
} bmp_img;
void bmp_header_init_df        (bmp_header*, const int, const int);
enum bmp_error bmp_header_write(const bmp_header*, FILE*         );
enum bmp_error bmp_header_read (bmp_header*, FILE*               );
void bmp_pixel_init            (bmp_pixel*, const unsigned char   ,
                                const unsigned char, const unsigned char);
void bmp_img_alloc             (bmp_img*                         );
void bmp_img_init_df           (bmp_img*, const int, const int   );
void bmp_img_free              (bmp_img*                         );
enum bmp_error bmp_img_write   (const bmp_img*, const char*      );
enum bmp_error bmp_img_read    (bmp_img*, const char*            );

#endif                         /// LIBBMP_H_INCLUDED

e o código do header   imghelpers :

#ifndef IMGHELPERS_H
#define IMGHELPERS_H
#include <stdio.h>
typedef struct IMG_TAM
{
  int qtdLinhas;
  int qtdColunas;
};
typedef struct IMG_TAM IMG_TAM;
IMG_TAM pegarTamanho(const char *filename);
void carregaImagem(
    IMG_TAM t,
    int R[t.qtdLinhas][t.qtdColunas],
    int G[t.qtdLinhas][t.qtdColunas],
    int B[t.qtdLinhas][t.qtdColunas],
    const char *filename);
void salvaImagem(
    IMG_TAM t,
    int R[t.qtdLinhas][t.qtdColunas],
    int G[t.qtdLinhas][t.qtdColunas],
    int B[t.qtdLinhas][t.qtdColunas],
    const char *filename);
void zerarPixels(
    IMG_TAM t,
    unsigned char PIX[t.qtdLinhas][t.qtdColunas]);
void mostrarNoReplit(const char *filename);

#endif                /// IMGPHELPERS_H_INCLUDED

e aqui o código da   libbmp. c  :

/// Aqui ColoQue O cOdigo Das FunCOes
void bmp_header_init_df(bmp_header *header, const int width, const int height)
{
    header->bfSize =
        (sizeof(bmp_pixel)  * width + BMP_GET_PADDING(width)) * abs(height);
    header->bfReserved      = 0;
    header->bfOffBits       = 54;
    header->biSize          = 40;
    header->biWidth         = width;
    header->biHeight        = height;
    header->biPlanes        = 1;
    header->biBitCount      = 24;
    header->biCompression   = 0;
    header->biSizeImage     = 0;
    header->biXPelsPerMeter = 0;
    header->biYPelsPerMeter = 0;
    header->biClrUsed       = 0;
    header->biClrImportant  = 0;
}
enum bmp_error bmp_header_write(const bmp_header *header, FILE *img_file)
{
    if (header == NULL)
    {
        return BMP_HEADER_NOT_INITIALIZED;
    }
    else if (img_file == NULL)
    {
        return BMP_FILE_NOT_OPENED;
    }
    const unsigned short magic = BMP_MAGIC;
    fwrite(&magic, sizeof(magic), 1, img_file);
    fwrite(header, sizeof(bmp_header), 1, img_file);
    return BMP_OK;
}
enum bmp_error bmp_header_read(bmp_header *header, FILE *img_file)
{
    if (img_file == NULL)
    {
        return BMP_FILE_NOT_OPENED;
    }
    unsigned short magic;
    if (fread(&magic, sizeof(magic), 1, img_file) != 1 || magic != BMP_MAGIC)
    {
        return BMP_INVALID_FILE;
    }
    if (fread(header, sizeof(bmp_header), 1, img_file) != 1)
    {
        return BMP_ERROR;
    }
    return BMP_OK;
}
void bmp_pixel_init(bmp_pixel *pxl, const unsigned char red,
                    const unsigned char green, const unsigned char blue)
{
    pxl->red   = red;
    pxl->green = green;
    pxl->blue  = blue;
}
void bmp_img_alloc(bmp_img *img)
{
    const
    size_t        h = abs(img->img_header->biHeight);
    img->img_pixels = malloc(sizeof(bmp_pixel *) * h);
    for (size_t y   = 0; y < h; y++)
    {
        img->img_pixels[y] = malloc(sizeof(bmp_pixel) * img->img_header->biWidth);
    }
}
void bmp_img_init_df(bmp_img *img, const int width, const int height)
{
    bmp_header_init_df(&img->img_header, width, height);
    bmp_img_alloc(img);
}
void bmp_img_free(bmp_img *img)
{
    const size_t h = abs(img->img_header->biHeight);
    for (size_t y = 0; y < h; y++)
    {
        free(img->img_pixels[y]);
    }
    free(img->img_pixels);
}
enum bmp_error bmp_img_write(const bmp_img *img, const char *filename)
{
    FILE *img_file = fopen(filename, "wb");
    if (img_file == NULL)
    {
        return BMP_FILE_NOT_OPENED;
    }
    const enum bmp_error err = bmp_header_write(&img->img_header, img_file);
    if (err != BMP_OK)
    {
        fclose(img_file);
        return err;
    }
    const size_t h = abs(img->img_header->biHeight);
    const size_t offset = (img->img_header->biHeight > 0 ? h - 1 : 0);
    const unsigned char padding[3] = {'\0', '\0', '\0'};
    for (size_t y = 0; y < h; y++)
    {
        fwrite(img->img_pixels[offset - y], sizeof(bmp_pixel),
               img->img_header->biWidth, img_file);
        fwrite(padding, sizeof(unsigned char),
               BMP_GET_PADDING(img->img_header->biWidth), img_file);
    }
    fclose(img_file);
    return BMP_OK;
}
enum bmp_error bmp_img_read(bmp_img *img, const char *filename)
{
    FILE *img_file = fopen(filename, "rb");
    if (img_file == NULL)
    {
        return BMP_FILE_NOT_OPENED;
    }
    const enum bmp_error err = bmp_header_read(&img->img_header, img_file);
    if (err != BMP_OK)
    {
        fclose(img_file);
        return err;
    }
    bmp_img_alloc(img);
    const size_t h       = abs(img->img_header->biHeight);
    const size_t offset  = (img->img_header->biHeight > 0 ? h - 1 : 0);
    const size_t padding = BMP_GET_PADDING(img->img_header->biWidth);
    const size_t items   = img->img_header->biWidth;
    for ( size_t y       = 0; y < h; y++)
    {
        if (fread(img->img_pixels[offset - y], sizeof(bmp_pixel), items,
                  img_file) != items)
        {
            fclose(img_file);
            return BMP_ERROR;
        }
        fseek(img_file, padding, SEEK_CUR);
    }
    fclose(img_file);
    return BMP_OK;
}

e o código da função     imghelpers.c   :

/// Aqui ColoQue Os cOdigo Das FunCOes

typedef struct bmp_img;
typedef struct IMG_TAM;
typedef bmp_img;
IMG_TAM pegarTamanho(const char *filename)
{
    /// coloque o cOdigo Aqui, o q voce quer q ele faCa .
    printf("Você não tinhA essa FuCAo . !\n");
    return;
}
void salvaImagem /// funCAo salvar imagem
(IMG_TAM t, int R[t.qtdLinhas][t.qtdColunas],
 int G[t.qtdLinhas][t.qtdColunas],
 int B[t.qtdLinhas][t.qtdColunas],
 const char *filename)
{
    /// coloque o cOdigo Aqui, o q voce quer q ele faCa .
    return;
}
void mostrarNoReplit(const char *filename)
{
    return;
}
void carregaImagem(
    IMG_TAM t,
    int R[t.qtdLinhas][t.qtdColunas],
    int G[t.qtdLinhas][t.qtdColunas],
    int B[t.qtdLinhas][t.qtdColunas],
    const char *filename)
{
    /// coloque o cOdigo Aqui, o q voce quer q ele faCa .
    return;
}

porém essas funções que fazem as modificações nas imagens , não estão prontas , pois falta exatamente um código para fazer tais modificações .

@Eli Almeidaa    se você quiser pode marcar essa minha resposta de cima , no #10 , como solução . .  !

@Eli Almeidaa   está certo , sim , porém faltou um código para a opção 4 do menu ,  que sugere mostrar Todos os produtos cadastrados ,   imagino algo assim :

Algoritmo "Gerenciamento de Produtos_2"
const
   quantidadeMaximaProdutos = 2

tipo
   loja       = registro
      nome    : caractere
      preco   : real
      estoque : inteiro
   fimRegistro

var
   produtos                      : vetor [1..quantidadeMaximaProdutos] de loja
   quantidadeProdutosCadastrados : inteiro
   opcao, r, quantidade,a        : inteiro
   nome, opcao2                  : caractere

funcao produtoExiste( nome : caractere ) : inteiro
var
   contador, resultado : inteiro
inicio
   para contador   <- 1 ate quantidadeProdutosCadastrados faca
      se nome      =  produtos[contador].nome então
         resultado <- contador
         interrompa()
      fimse
   fimPara
   retorne resultado
fimFuncao

procedimento cadastrarProduto()
inicio
   escreval("Informe o nome do produto")
   leia(nome)
   se produtoExiste(nome) > 0 então
      escreval("O produto ", produtos[quantidadeProdutosCadastrados].nome, " Já existe no cadastro!")
   senao
      produtos[ quantidadeProdutosCadastrados].nome <- nome
      escreval( "Informe o preço do produto")
      leia    ( produtos[quantidadeProdutosCadastrados].preco)
      escreval( "Informe o estoque do produto")
      leia    ( produtos[quantidadeProdutosCadastrados].estoque)
      quantidadeProdutosCadastrados <- quantidadeProdutosCadastrados+1
      escreval( "Produto cadastrado com sucesso")
   fimSe
fimProcedimento

funcao consultarEstoque( nome : caractere ) : inteiro
var
   contador  : inteiro
   resultado : inteiro
inicio
   para  contador  <- 1 ate quantidadeProdutosCadastrados faca
      se nome      =  produtos[contador].nome então
         resultado <- produtos[contador].estoque
         interrompa()
      fimSe
   fimPara
   retorne resultado
fimFuncao

funcao atualizarEstoque ( opcao2 : caractere ; quantidade : inteiro ) : inteiro
var
   contador, c : inteiro
inicio
   para contador  <- 1 ate quantidadeProdutosCadastrados faca
      se opcao2   = "R" então
         produtos[contador].estoque <-  produtos[contador].estoque - quantidade
         c <- produtos[contador].estoque
         interrompa
      senao
         se opcao2 = "A" então
            produtos[contador].estoque <-  produtos[contador].estoque + quantidade
            c <- produtos[contador].estoque
            interrompa
         fimSe
      fimse
   fimPara
   retorne c
fimfuncao

Inicio

   quantidadeProdutoscadastrados <- 1
   repita
      limpatela("")
      escreval (" [0] - Sair  Do ProGrama")
      escreval (" [1] - Cadastrar produto")
      escreval (" [2] - consultar produto")
      escreval (" [3] - atualizar estoque")
      escreval (" [4] - listar   produtos")
      escreval ("Escolha uma opcao "      )
      leia     ( opcao                    )
      limpatela("")
      escolha opcao
      caso 1
         se quantidadeProdutosCadastrados <= quantidadeMaximaProdutos então
            cadastrarProduto()
         senao
            escreval(" Limite de cadastro atingido")
         fimSe
      caso 2
         escreval ("Informe o nome do produto que deseja consultar o estoque")
         leia( nome )
         r <- produtoExiste(nome)
         se r > 0 então
            r <- consultarEstoque(nome)
            escreval(" A quantidade de estoque do produto ", nome, " é ", r:1)
         senao
            escreval(" Produto não cadastrado.")
         fimSe
      caso 3
         escreval ("Informe o nome do produto que deseja atualizar o estoque")
         leia( nome )
         r <- produtoExiste(nome)
         se r > 0 então
            escreval( "[R] - retirar  " )
            escreval( "[A] - adicionar" )
            leia    ( opcao2            )
            opcao2 <- maiusc( opcao2    )
            se opcao2 = "R" então
               escreval ("Quanto gostaria de retirar" )
               leia     ( quantidade                  )
               r <- atualizarEstoque(opcao2,quantidade)
               escreval("O novo estoque é de ", nome, " é ", r:1)
            senao
               se opcao2 = "A" então
                  escreval ("Quanto gostaria de adicionar")
                  leia     ( quantidade                   )
                  r <- atualizarEstoque(opcao2,quantidade )
                  escreval("O novo estoque é de ", nome, " é ", r:1)
               fimse
            fimse
         senao
            escreval(" Produto não cadastrado.")
         fimSe
      caso 4
        EscrevaL("   Listando Todos Prod Cadastrados"  )
        para a de 1 ate quantidadeProdutosCadastrados-1 faca
          EscrevaL("Dados Do ",a,"º Produto"           )
          escreval("Produto -: ",produtos[a].nome      )
          escreval("PreCo ---:" ,produtos[a].preco   :5)
          escreval("PreCo ---:" ,produtos[a].estoque :5)
          EscrevaL("")
        fimpara
      fimescolha
      se opcao <> 0 então
        EscrevaL("")
        EscrevaL("   Tecle Enter ")
        leia(a)
      fimse
   ate ( opcao = 0 )

Fimalgoritmo

ou  de algum outro modo que melhor lhe agradar ,  com as formatações , textos de mensagens e opções de pausas  para ver os resultados .

@Eli Almeidaa   essa Função "produtoExiste" contém um erro , pois no visualG o comando retorne funciona de outra forma , pois ele não retorna imediatamente , não , e só retorna mesmo no final da função , assim você precisa fazer o controle do valor que será retornado, usando uma variável auxiliar ,  e lá no final da Função,  no comando retorne, coloque esse valor que será retornado aí sim nesse momento , 

funcao produtoExiste(nome:caractere):inteiro
var
   contador, flg:inteiro
inicio

   para contador <- 1 ate quantidadeProdutosCadastrados faca
      se nome = produtos[contador].nome então
         // retorne contador não iRah retornar nada aqui
         flg := contador     /// armazena o valor que será retornado
         interrompa("32768") /// interrompe o loop para / fimpara
      fimse
   fimPara
   retorne flg               /// aqui sim , vai retornaR o valor deseJado .
fimFuncao

@matheus.Matta   essas bibliotecas foi você que as criou , então coloque-as na mesma pasta onde está o código de seu algoritmo ,  e se você puder / Quiser , poste essas bibliotecas que parecem bastante interessantes .

@paulovitorr223   um "ranking"  simples  pode ser apenas adicionar mais um ao valor da variável a cada acerto , 

ranki++;

assim ao digitar   'r'  , vai mostrar o valor atual dessa variável com a quantidade acertos .    você colocou a função "srand" para gerar números  aleatórios , e isso está certo mesmo ,  porém ela só precisam ser colocada uma vez em todo seu código ,   e também colocou muitas  "system("cls");"  , sem necessidade .  e seu código usando a formatação ficaria assim :

#define     _WIN32_WINNT 0x600
#define     _h GetStdHandle(STD_OUTPUT_HANDLE)
#include    <stdio.h>
#include    <iso646.h>
#include    <stdlib.h>
#include    <string.h>
#include    <windows.h>
#include    <math.h>
#include    <time.h>
#include    <locale.h>
#include    <iostream>
#include    <string>
#include    <set>
using namespace std;
void	getch();
int main    ( int argc, char *argv[]                     )
{
  int letra,fundo;
  CONSOLE_SCREEN_BUFFER_INFO _c                          ;
  if( GetConsoleScreenBufferInfo     ( _h, & _c )        )
  {
    letra = (   _c.wAttributes & 0xFF )            & 0x0F;
    fundo = ( ( _c.wAttributes & 0xFF ) >> 4    )  & 0x0F;
  }
  SetConsoleTextAttribute( _h, 11 +       ( 0 << 4 )    );
  ///------------------------------------------------------

  setlocale (LC_ALL, "");
  int ranki=0, ranki2=0;
  srand (time(NULL)); /// isso só precisa uma Unica vez em todo o cOdigo
  char escolha = 'v', dificuldade='m';
  //Início
  while (escolha != 'f')
  {
    system("cls");
    /// Verificar  a   dificuldade
    cout << "Dificuldade atual: ";
    if      (dificuldade == 'f'  )
      cout << "Fácil"     << endl;
    else if (dificuldade == 'd'  )
      cout << "Difícil"   << endl;
    else
      cout << "Média" << endl;
    /// Menu
    /// Caso queira adicionar mais uma opção, coloque a letra inicial da
    /// opção Ex.: r de Ranking. Então faça mais um else if com essa
    /// opção e coloque no menu.
    cout << "Para escolher, digite a primeira letra da opção.\n"
         "//  - Jogar      \n"
         "//  - Dificuldade\n"
         "//  - Sobre      \n"
         "//  - Fim        \n"
         "//  - Ranking "    ;
    cin >> escolha;
    system("cls");
    //Sobre
    if (escolha == 's')
    {
      cout << "jogo feito por." << endl;
      cout << "//Voltar" << endl;
      cin >> escolha;
    }
    //Fim
    else if (escolha == 'r')
    {
      cout<< "Rank --: " << ranki << "\n Tecle";
      getch();
    }
    //Dificuldade
    else if (escolha == 'd')
    {
      cout <<
           "//  Fácil ---: 3 dígitos, 08 tentativas.\n"
           "//  Média ---: 4 dígitos, 10 tentativas.(Padrão Inicial)\n"
           "//  Difícil -: 5 dígitos, 12 tentativas.\n"
           "//  Voltar --: ";
      cin >> dificuldade;
      //Fácil
      if (dificuldade == 'f')
      {
        int numero;
        string valor;
        for(int i = 0; i < 3; i++)
        {
          numero = rand()%3+1;
          cout << numero<< " ";
          valor += to_string(numero);
        }
        cout << endl << endl << valor;
      }
      //Difícil
      else if (dificuldade == 'd')
      {
        int numero;
        string valor;
        for(int i = 0; i < 5; i++)
        {
          numero = rand()%5+1;
          cout << numero<< " ";
          valor += to_string(numero);
        }
        cout << endl << endl << valor;
      }
      //Média
      else
      {
        int numero;
        string valor;
        for(int i = 0; i < 4; i++)
        {
          numero = rand()%4+1;
          cout << numero<< " ";
          valor += to_string(numero);
        }
        cout << endl << endl << valor;
      }
      escolha = 'v';
    }
    //O Jogo
    else if (escolha == 'j')
    {
      do
      {
        string senha;
        system("cls");
        int numero;
        string valor;
        set<int> numerosgerados; // Para registrar os numeros
        // Checagem de dificuldade e geração dos números
        int maxnumero;
        if (dificuldade == 'f')
        {
          maxnumero = 3;
        }
        else if (dificuldade == 'd')
        {
          maxnumero = 5;
        }
        else
        {
          maxnumero = 4;
        }
        while (numerosgerados.size() < maxnumero)
        {
          numero = rand() % 6 + 1;
          if (numerosgerados.find(numero) == numerosgerados.end())
          {
            numerosgerados.insert(numero);
            valor += to_string(numero);
          }
        }
        //cout << "Número gerado: " << valor << endl;   para testes
        // Verificação de tentativas
        int tentativas;
        if (dificuldade == 'f')
        {
          tentativas = 8;
        }
        else if (dificuldade == 'd')
        {
          tentativas = 12;
        }
        else
        {
          tentativas = 2; /// p testar , deps coloc outr val
        }
        while (tentativas > 0 && senha != valor )
        {
          cout << "Tentativas restantes: " << tentativas << endl;
          // Resposta do usuário e a comparação
          cout << "Digite um número com " << maxnumero << " dígitos: ";
          cin >> senha;
          system("cls");
          cout << senha << endl;
          int acertosNaPosicao = 0;
          int acertosForaPosicao = 0;
          for (int i = 0; i < maxnumero; i++)
          {
            if (senha[i] == valor[i])
            {
              acertosNaPosicao++;
            }
            else if (valor.find(senha[i]) != string::npos)
            {
              acertosForaPosicao++;
            }
          }
          //retorno
          cout << "Dígitos corretos na posição correta -----: " << acertosNaPosicao   << endl;
          cout << "Dígitos corretos, mas na posição errada -: " << acertosForaPosicao << endl;
          tentativas = tentativas - 1;
          if (senha == valor)
          {
            cout << "Você ganhou, a senha era mesmo " << valor << endl;
            ranki++;
          }
          else if (tentativas == 0)
          {
            cout << "Você perdeu, a senha era: " << valor << endl;
          }
          numerosgerados.clear();
          cout << " Tecle\n";
          getch();
        }
        if (senha == valor || tentativas == 0)
        {
          //Opções depois do jogo acabar
          cout <<
               "//  Jogar Novamente.\n"
               "//  Voltar ao Menu. \n"
               "//  Acessar Ranking " ;
          cin  >>   escolha           ;
        }
      }
      while ( escolha == 'j' );
    }
  }
  SetConsoleTextAttribute( _h, 15 +  ( 12 << 4 )  );
  cout << "\n  Saindo Do Jogo . . . !  ";

  ///------------------------------------------------------
  SetConsoleTextAttribute( _h, letra +  ( fundo << 4 )  );
  printf("\n\n\n");
  return                                                0;
}
void	getch()
{
  FlushConsoleInputBuffer(GetStdHandle(STD_INPUT_HANDLE));
  WaitForSingleObject(GetStdHandle(STD_INPUT_HANDLE), INFINITE);
}

@Ataide01    qual IDE você está usando ? ,  pois no visual studio , já há um código inserido com essa mensaGem  "Hello, Word's !"  ,  ou se for no codeblocks ou Dev C++,  pode ser que você tenha um projeto aberto , assim ,o compilador vai direto no projeto primeiro , e deixa o  código de console para depois , então feche o projeto e vai funcionar normal .

@Álvaro Dínamo    o processador desse seu notebook pode ter pifado mesmo , afinal  são mais de 6 anos  e os notebooks não tem boa refrigeração ,  mas não é a pasta térmica que iria ou irá salva-lo , não ,  geralmente não se precisa substituir pasta térmica ,  experimente colocar outro processador ,  e se funcionar , muito que bem , mas senão outra placa mesmo .

@JOTAFBR      muito bem , seu código funciona bem ,  e você poderia dar uma melhor apresentação de saída no console :

algoritmo "Tabuada do 1 ao 10"
// Data : 09/10/2023
var
   i,j:inteiro
inicio
   EscrevaL("Tabuada geral")
   EscrevaL("")

   Para i de 1 ate 10 faca
      escreval("")
      Escreval("  Tabuada de",i)
      escreval("")
      Para j de 0 ate 10 faca
         se i < 10 então
            Escreva(" ")
         fimse
         Escreva( i ," x")
         se j < 10 então
            escreva(" ")
         fimse
         escreva( j," =" )
         se j*i < 10 então
            escreva("  ")
         senao
            se j*i < 100 então
               escreva(" ")
            fimse
         fimse
         escreval( j * i)
      fimpara
   fimpara
   EscrevaL(" ")
   EscrevaL(" ")

fimalgoritmo

@consistente     essa informação que o visualG mostra sobre o "então"  é muito comum  ,  e geralmente nada a ver com esse comando "então" , e com certeza o erro é em outro local do Algoritmo , e  se você observar , notará que seu código tem um erro de syntaxes , ou seja , você colocou um comado  escrito de forma inadequada para o compilador do vidualG ,  aqui nessas Linhas:

para x de 1 ate 10 faca
  escreva("Digite a ", x, "ª letra: ")
  leia(num[x])           /// num eh um vetor , precisa dos colchetes "num[x]"
  se num[x] = "a" então  /// a eh do tipo caractere com aspas Duplas
    /// letraA <- + 1    /// assim a var "letraA" conterá apenas o val 1
    letraA <- letraA + 1 /// aqui soma acumulando o val
                         /// e a var "letraA" conterá o val dela mais o val 1            
  fimse
fimpara

e você pode baixar a versão estável do visualG 3.0.6.5 , nesse link:

https://sourceforge.net/projects/visualg30/files/

e escolha a opção "File"  e depois o arquivo da versão  que você Quer . assim :

@cabralito    creio que não se possa misturar c++ com c# , pois as bibliotecas das duas linguagens são diferentes ,  e também as funções do c sharp são apropriadas para esse tipo de aplicativo "Windows form's" e no c++ não tem tais funções ,  então você precisaria mesmo é usar uma biblioteca externa , como a Allegro , Qt, wxWidget, e outras tantas .

@Abner Assis     se os dispositivos forem todos atuais , serão compatíveis ,  pois os conectores  serão do mesmo tipo ,  pl de vídeo , memória , placa-mãe , SSD e fonte ,  mas se você misturar coisa antigas com outras nova , aí pode ser que não seja compatível .

@Tati Schein    seu código funciona bem ,mas faltou a função de melhoria da imagem ,

@GustavoGlwan    o IDE pyCharm é muito bom ,mesmo ,  e esse Comando para limpar o console no modo "run"  precisam ser configurado na aba    run / Debug / EditConfiguration , e marcar a caixa "emulate terminal in output console" e funciona bem tanto no Windows quanto no Linux , usando  assim :

import os
os.system("cls||clear") # funciona no Windows e Linux

um código de exemplo :

import os
from time import sleep
import time, sys
print('  pausar 1 Segundo.')
for i in range(10, -1,-1): # Loop for Gressivo
    sys.stdout.write("\r   Time.Regress --> [  {}   ]  <--      ".format(i))
    sys.stdout.flush()
    time.sleep(1)

# Recebe a frase do usuário
frase = input("\nDigite uma frase: ")

# Divide a frase em palavras
palavras = frase.split()
print(frase)
print('Limpar a tela em 3 Segundo.')
sleep( 3 )
os.system("cls||clear") # funciona no Windows e Linux
print('Uma Letra a cada 4 Décimos De Segundo.\nFrase Invertidas  ',end='')
for f in range(len(frase)-1,-1,-1):
    print(frase[f],end='')
    sleep(0.41)

print('\nFrase Digitadas  ',frase)

@XxarseniumxX    poste o código que você tenha feito sobre esse exercício , e ajudaremos  .

@Gabriel GN   essa linha no começo da tela do console não é usada

e está imprimindo uma coluna à frente das outras linhas , do modo que você colocou  ,  e então corrigindo , ficaria assim :

algoritmo "Triangulo"
var
   L1, L2, L3 : Real
   EQ, ES, TRI: Logico
inicio
   Escreva ("Escreva o primeiro lado -: ")
   Leia (L1)
   Escreva ("Escreva o segundo lado --: ")
   Leia (L2)
   Escreva ("Escreva o terceiro lado -: ")
   Leia (L3)
   TRI <- ( L1 <  L2+L3 ) e ( L2 <  L1+L3 ) e ( L3 < L1+L2 )
   EQ  <- ( L1 =  L2)     e ( L2 =  L3)
   ES  <- ( L1 <> L2)     e ( L1 <> L3) e (L2<>L3)
   Escreval ("o triangulo é existente  ? ", TRI)
   Escreval ("o triangulo é equilatéro ? ", EQ )
   Escreval ("o triangulo é escaleno   ? ", ES )
fimalgoritmo

@Caio Fernandes1    o código do  @Marcelo Augusto ZCK  está bem explicado ,  e com informações para quem for usar , mas  não está seguindo o que diz o enunciado ,  que diz para enviar o número de clientes para a função ,  então creio que , também poderia ser assim  :

#define     _WIN32_WINNT 0x600
#define     _h GetStdHandle(STD_OUTPUT_HANDLE)
#include    <stdio.h>
#include    <conio.h>
#include    <iso646.h>
#include    <stdlib.h>
#include    <string.h>
#include    <windows.h>
#include    <math.h>
#include    <iostream>
/***
     Descontar uma taxa de administração de R$12,47 .
  a) Faça uma função que receba como parâmetro o
     número de clientes do banco. Para cada cliente,
     a função deverá ler o saldo atual, calcular e
     imprimir o valor do saldo após o desconto. Caso,
     após a operação, o saldo esteja negativo, a
     função deverá imprimir a frase
     “SALDO NEGATIVO, CLIENTE DEVE SER COMUNICADO”.
  b) Faça um programa (função main) que leia o
     número de clientes do banco e chame a função da letra a.
***/
using namespace std;
void comunicarcliente(int numcliente)
{ ///                            ▲
  /// cin>>numcliente; já obteve | essa inform
  float saldo;
  for(int i=0; i<numcliente; i++)
  {
    saldo = 0;      /// resetar a variaVL
    cout << "Saldo Atual do Clinte " << i+1 << " --: ";
    cin  >> saldo;
    saldo -= 12.47; /// economiza uma variAveL
    cout << "ValoR Apos o Desconto " << saldo << " <----\n" << endl;
    if( saldo < 0 )
      cout << "SALDO NEGATIVO, CLIENTE DEVE SER COMUNICADO" << endl;
  }
}
int main    ( int argc, char *argv[]                     )
{
  int letra,fundo;
  CONSOLE_SCREEN_BUFFER_INFO c                           ;
  if( GetConsoleScreenBufferInfo     ( _h, & c )         )
  {
    letra = (   c.wAttributes & 0xFF )             & 0x0F;
    fundo = ( ( c.wAttributes & 0xFF ) >> 4     )  & 0x0F;
  }
  SetConsoleTextAttribute( _h, 11 +       ( 0 << 4 )    );
  ///------------------------------------------------------
  
  int               numcliente  ;
  cout << "Num de Clinte's --: "; /// inf o que digitA
  cin >>            numcliente  ; /// leu o num de client's
  cout << endl;
  comunicarcliente( numcliente ); /// enviou p/ a func

  ///------------------------------------------------------
  SetConsoleTextAttribute( _h, letra +  ( fundo << 4 )  );
  return                                                0;
}

@Caio Fernandes1  e também , esse código  funciona apenas  um funcionários ,  e para mais outros use um Loop , 

#define     _WIN32_WINNT 0x600
#define     _h GetStdHandle(STD_OUTPUT_HANDLE)
#include    <stdio.h>
#include    <conio.h>
#include    <iso646.h>
#include    <stdlib.h>
#include    <string.h>
#include    <windows.h>
#include    <math.h>
#include    <iostream>
#include    <iomanip>
using namespace std;

float calcula_auxilio( float dependente )
{

  /// float numfuncionario=5; não esta sendo usada
  float auxilio = 0;
  int idade = 0;
  for(int i=0; i<dependente; i++) /// qtd de dependentes
  {
    cout << "Idade do " << i+1 << " Dependente ----: ";
    cin  >> idade;                /// idade de cada dependentes
    if( idade < 18 )
      auxilio += 60.00;           /// soma acumulando
  }
  /*  for(int i=0; i<5; i++) não precisa desse Looop's
      {
        return auxilio; o return não func assim , com vArios Retornos , não.  !
      }
  */
  return auxilio;                 /// só retorna um Unico VaLores
}

int main    ( int argc, char *argv[]                     )
{
  int letra,fundo;
  int func = 5;
  CONSOLE_SCREEN_BUFFER_INFO c                           ;
  if( GetConsoleScreenBufferInfo     ( _h, & c )         )
  {
    letra = (   c.wAttributes & 0xFF )             & 0x0F;
    fundo = ( ( c.wAttributes & 0xFF ) >> 4     )  & 0x0F;
  }
  SetConsoleTextAttribute( _h, 11 +       ( 0 << 4 )    );
  ///------------------------------------------------------

  int idade, numdependentes,auxilio, total;

  for( int f=0; f<func; f++)                          /// Todos os funcionArio
  {
    cout << "numero de dependentes Do " << f+1 << ": ";
    do
    {
      cin  >> numdependentes;/// >> idade; le apenas Uma Unica Idades
      if( numdependentes < 0 )cout << "Valor errado .  !" << endl;
    }while (  numdependentes < 0 );
    auxilio = calcula_auxilio( numdependentes ); /// Apenas para um Unico funcionArio
    total   = auxilio;

    SetConsoleTextAttribute( _h, 12 +  ( 15 << 4 )  );
    cout << "\n Auxilio Do " << f+1 <<" FuncionArio -: " << setw(4) << total << "  " << endl << endl;
    SetConsoleTextAttribute( _h, 14 +  ( 0 << 4 )  );
  }
  cout   << "\n\n                         " <<          endl;

  ///------------------------------------------------------
  SetConsoleTextAttribute( _h, letra +  ( fundo << 4 )  );
  return                                                0;
}

@Vaulot_Boi      ou você pode usar o comado "goto" , que funciona bem   .

@Midori     e também ,  poderia validar o Gabarito,  para não armazenar caracteres que não sejam números :

Algoritmo "Notas"
Const
   GMAX  = 5
   AMAX  = 3
Tipo
   TAluno = Registro
      Nome: Caractere
      Nota: Real
   FimRegistro
Var
   Gabarito : Vetor[1..GMAX] de Inteiro
   Aluno    : Vetor[1..AMAX] de TAluno
   I,p      : Inteiro
   J        : Inteiro
   Resposta : Inteiro
   Media    : Real
Inicio
   Media <- 0
   Escreval("-----------------------")
   Escreval(" ENTRE COM O GABARITO  ")
   Escreval("-----------------------")
   Para p <- 1 Ate GMAX Faca
      repita
         Escreva("Questão ", p, ": ")
         leia(ax)
         se ( asc(ax) < 48 ) ou ( asc(ax) > 57 ) então
           escreval("Erro, '",maiusc(ax),"' não é Número .")
         fimse
      ate caracpnum(ax) <> 0
      Gabarito[p] := caracpnum( ax )
   FimPara
   Para I <- 1 Ate AMAX Faca
      Aluno[I].Nota <- 0
      Escreva("Nome Aluno ", I, ": ")
      Leia(Aluno[I].Nome)
      Para J <- 1 Ate GMAX Faca
         Escreva("Resposta ", J, ": ")
         Leia(Resposta)
         Se(Resposta = Gabarito[J]) então
            Aluno[I].Nota <- Aluno[I].Nota + 10/GMAX
         FimSe
      FimPara
      Media <- Media + Aluno[I].Nota/AMAX
   FimPara
   Escreval("-----------------------")
   Escreval("        NOTAS          ")
   Escreval("-----------------------")
   Para I <- 1 Ate AMAX Faca
      Escreval(Aluno[I].Nome, " = ", Aluno[I].Nota)
   FimPara
   Escreval("Media da Turma = ", Media)
FimAlgoritmo

@louisecp     seu código está funcionando bem , mas é quase todo da linguagem 'C' e não C++, o que tem de C++ nesse seu código são o "cout <<" e o "cin >>" ,  e  P M G são caracteres do tipo "char" , com apenas uma única Letra , e para mais de uma Letra use "string" , e essa matriz é do tipo "int" ,  assim os valores guardados nela são também do tipo 'int' então use :

char matriz[4][4] ;
   
///    ou do modo que está use assim : (char) que é a letra e não o código da Letra
      
for(int i=0; i<numProdutos; i++)
{
  cout  <<        encomenda[i][0] << "\t" << (char)encomenda[i][1]
        << "\t"<< encomenda[i][2] << "\t" <<       encomenda[i][3]
        << "\t"<< encomenda[i][4] <<                         endl;


  }     

ou na linguagem C++ use o tipo "string" para armazenar palavras do modo que está no exemplo da descrição .

@jhonbi     poste um código que você já tenha sobre esse exercício , e ajudaremos .

Em 15/05/2023 às 14:57, Jackson Vanutty disse:

inteiro lucro_maximo = 0, lucro = 600, valor_ingresso = 5, numero_ingressos = 120, numero_ingressos_max
        real ingresso, x_ingresso

inicialize as variáveis

inteiro  lucro_maximo         = 0  ,   lucro            = 600 
inteiro  valor_ingresso       = 5  ,   numero_ingressos = 120
inteiro  numero_ingressos_max = 0
real     ingresso             = 0.0,   x_ingresso       = 0.0

@Jackson Vanutty    o tipo   é 

caractr letra

programa
{
    inclua biblioteca Texto --> tx
    funcao inicio()
    {

    cadeia   novoNome = "", nome = ""
    caractere letra  // ssem a letra "e" do final
    inteiro  i = 1

    escreva ("Digite o nome a ser criptografado: ")
    leia (nome)

        faca{
            letra = Texto.obter_caracter(nome, i-1)
            se(letra == 'A'    ou letra == 'a')
                novoNome = novoNome + "1"
            senao se(letra == 'E'    ou letra == 'e')
                novoNome = novoNome + "2"
            senao se(letra == 'I'    ou letra == 'i')
                novoNome = novoNome + "3"
            senao se(letra == 'O'    ou letra == 'o')
                novoNome = novoNome + "4"
            senao se(letra == 'U'    ou letra == 'u')
                novoNome = novoNome + "5"
            senao se(letra == ' ')
                novoNome = novoNome + '#'
            senao 
                novoNome = novoNome + letra
                i = 1 + i
            }
        enquanto(i<= Texto.numero_caracteres(nome))
        escreva ("O nome criptografado: ", novoNome)
    }
}

@Memylaurinha   a função GetLength(0);  obtém o número de Linhas  e GetLength(1);  , o número de colunas de uma matriz ,  e multiplicando  obtém o total de elementos da matriz ,  e você pode usar a função Random , para preencher a matriz com números aleatórios ,  e depois verificar os números para saber o que é maior e a posição "Linha / Coluna" da matriz , e depois que você fizer um código sobre esse exercício , poste ele aqui e ajudaremos se ainda precisar   .