CDC (Change Data Capture) é uma das novas e interessantes funcionalidades que chegou ao SQL Server (alguns de nós já a conhecíamos do ORACLE), permite detectar alterações (INSERT, DELETE, UPDATE) relativamente aos dados de uma tabela e replicá-las noutra tabela, sem recorrer aos tradicionais triggers ou outras metodologias mais rebuscadas.
João Paulino
/******************************************************************************
COPYRIGHT: João Paulino
NAME: pir_num_inv.c
PURPOSE: desenhar uma prirâmide de Números invertida
REVISIONS:
Ver DATE Author Description
——— ———- ————— ————————————
1.0 João Paulino 1. Created this Program.
NOTES:
OBJECT NAME:
DATE AND TIME:
Username:
******************************************************************************/
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
void main (void)
{
int i, j, k;
char opt; // declarar variável para controlo da repetição da execução do programa
do // ciclo que controla a repetição da execução do programa
{
printf (“\nDigite um número [1-9] e pressione enter:”); // Mensagem para o utilizador digitar um número
if (scanf(“%d”, &k) == 1) // atribuir o valor digitado à variável n e validar se é do tipo inteiro if(valor)==1)
{
if (k > 9 ) // verificar a condição k não pode ser maior do que 9
printf(“O inteiro %d digitado não permite aplicar o algoritmo\n “,k); // Mensagem para o utilizador indicando que não é possível aplicar o algoritmo
else // caso se verifique a condição k <= 9
{
for (i = k; i >= 1; i–)
{
for (j= i+1 ; j <= k; j++)
printf(” “);
for (j = 1; j <= i; j++)
printf(“%d”, j);
for (j = i-1; j >=1; j–)
printf(“%d”, j);
printf(“\n”);
}
}
}
else // não foi digitado um número
{
printf (“\nNão digitou um algarismo ou número!!!”); // Mensagem para o utilizador a informar que não foi digitado um número
}
fflush(stdin); // escreve para o stream indicado qualquer dado armazenado, limpando-o
printf (“\nDeseja continuar? (S/N):”);
do
{
opt = toupper(getchar()); // recebe a entrada digitada e converte-a em maiúscula para facilitar
if ((opt != ‘S’) && (opt != ‘N’)) // caso a entrada não seja S ou N
putch(7); // faz soar o sino 
} while ((opt != ‘S’) && (opt != ‘N’)); // repete a captura da opção enquanto a condição for verdadeira
} while (opt != ‘N’); // repete o programa enquanto a condição for verdadeira
} // fim da função main
João Paulino
/******************************************************************************
COPYRIGHT: João Paulino
NAME: pir_num.c
PURPOSE: desenhar uma pirâmide de Números
REVISIONS:
Ver DATE Author Description
——— ———- ————— ————————————
1.0 João Paulino 1. Created this Program.
NOTES:
OBJECT NAME:
DATE AND TIME:
Username:
******************************************************************************/
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
void main (void)
{
int i, j, k;
char opt; // declarar variável para controlo da repetição da execução do programa
do // ciclo que controla a repetição da execução do programa
{
printf (“\nDigite um número [1-9] e pressione enter:”); // Mensagem para o utilizador digitar um número
if (scanf(“%d”, &k) == 1) // atribuir o valor digitado à variável n e validar se é do tipo inteiro if(valor)==1)
{
if (k > 9 ) // verificar a condição k não pode ser maior do que 9
printf(“O inteiro %d digitado não permite aplicar o algoritmo\n “,k); // Mensagem para o utilizador indicando que não é possível aplicar o algoritmo
else // caso se verifique a condição k <= 9
{
for (i = 1; i <= k; i++)
{
for (j= i+1 ; j <= k; j++)
printf(” “);
for (j = 1; j <= i; j++)
printf(“%d”, j);
for (j = i-1; j >=1; j–)
printf(“%d”, j);
printf(“\n”);
}
}
}
else // não foi digitado um número
{
printf (“\nNão digitou um algarismo ou número!!!”); // Mensagem para o utilizador a informar que não foi digitado um número
}
fflush(stdin); // escreve para o stream indicado qualquer dado armazenado, limpando-o
printf (“\nDeseja continuar? (S/N):”);
do
{
opt = toupper(getchar()); // recebe a entrada digitada e converte-a em maiúscula para facilitar
if ((opt != ‘S’) && (opt != ‘N’)) // caso a entrada não seja S ou N
putch(7); // faz soar o sino
} while ((opt != ‘S’) && (opt != ‘N’)); // repete a captura da opção enquanto a condição for verdadeira
} while (opt != ‘N’); // repete o programa enquanto a condição for verdadeira
} // fim da função main
João Paulino
Aqui vou colocar um algoritmo para resolver a situação apresentada.
Seja n o número introduzido, temos a + b + c =n e há que garantir a < b < c.
DECLARAR a, b, c, n como inteiro
LER n
a = 1
b = 2
c = n – (a + b)
SE (b >= c)
ESCREVER não é possivel porque b>= c
SENÃO
ENQUANTO (b < c)
ENQUANTO (a < b) E (b < c))
ESCREVER a + b + c = n (a, b, c, n)
b = b + 1
c = c – 1
FIM ENQUANTO
a = a + 1
b = a + 1
c = n – (a + b)
FIM ENQUANTO
FIM SE
Vamos agora à linguagem C, primeiro com programa um simples e depois mais complicados.
/******************************************************************************
COPYRIGHT: João Paulino
NAME: dec_somas
PURPOSE: decompor um numero n em somas de 3 parcelas em que a < b < c e
a + b + c = n
REVISIONS:
Ver DATE Author Description
——— ———- ————— ————————————
1.0 João Paulino 1. Created this Program.
NOTES:
OBJECT NAME:
DATE AND TIME:
Username:
******************************************************************************/
#include <stdio.h>
int main(void) // a função main
{
// declarar a variáveis que armazena o valor introduzido e os valores calculados os quais
// são associados a posições específicas da memória e que possuem um endereço único
// como a própria variável sugere, os valores aí armazenados podem variar ou mudar durante
// o tempo de execução do programa
// cada variável possue um tipo específico, que indica a quantidade de memória que os dados
// aí guardados exigem e que tipo de operações podem sofrer
int n, a, b, c; // declarar variáveis do tipo inteiro n, a, b, c
printf (“\nDigite um algarismo ou número e pressione enter:”); // Mensagem para o utilizador digitar um número
scanf(“%d”, &n); // atribuir o valor digitado à variável n
a = 1, b = 2, c = n -(a + b); // atribuir os valores iniciais às variáveis
if (b >= c) // verificar a primeira condição b não pode ser igual ou menor do que c
printf(“O inteiro %d digitado não permite aplicar o algoritmo\n “,n); // Mensagem para o utilizador indicando que não é possível aplicar o algoritmo
else // caso se verifique a condição b < c
{
while (b < c )
{
while((a < b) && (b < c) )
{
printf(“%3d + %3d + %3d = %3d\n”,a,b,c,n); // Imprimir no écran os valores
b++; // incrementar b uma unidade
c–; // decrementar c uma unidade
}
a++; // incrementar a uma unidade
b = a + 1; // atribuir o valor de a incrementado de uma unidade a b
c = n-( a + b ); // realizar o cálculo de c para ser validado
} // enquanto se verifique a condição b < c
}
} // fim da função main
/****************************************************************************************************************/
/******************************************************************************
COPYRIGHT: João Paulino
NAME: dec_somas
PURPOSE: decompor um numero n em somas de 3 parcelas em que a < b < c e
a + b + c = n
REVISIONS:
Ver DATE Author Description
——— ———- ————— ————————————
1.0 João Paulino 1. Created this Program.
NOTES:
OBJECT NAME:
DATE AND TIME:
Username:
******************************************************************************/
#include <stdio.h>
void main(void) // a função main esta declarada assim para gerar contradições com o programadores mais experientes
{ // para não termos warnings (avisos) no compitador colocariamos int main (void) e return 0; antes do fim da função main última }
// declarar a variáveis que armazena o valor introduzido e os valores calculados os quais
// são associados a posições específicas da memória e que possuem um endereço único
// como a própria variável sugere, os valores aí armazenados podem variar ou mudar durante
// o tempo de execução do programa
// cada variável possue um tipo específico, que indica a quantidade de memória que os dados
// aí guardados exigem e que tipo de operações podem sofrer
int n, a, b, c; // declarar variáveis do tipo inteiro n, a, b, c
char opt; // declarar variável para controlo da repetição da execução do programa
do // ciclo que controla a repetição da execução do programa
{
printf (“\nDigite um algarismo ou número e pressione enter:”); // Mensagem para o utilizador digitar um número
if (scanf(“%d”, &n) == 1) // atribuir o valor digitado à variável n e validar se é do tipo inteiro if(valor)==1)
{
a = 1, b = 2, c = n -(a + b); // atribuir os valores iniciais às variáveis
if (b >= c) // verificar a primeira condição b não pode ser igual ou menor do que c
printf(“O inteiro %d digitado não permite aplicar o algoritmo\n “,n); // Mensagem para o utilizador indicando que não é possível aplicar o algoritmo
else // caso se verifique a condição b < c
{
while ( b < c )
{
while( (a < b) && (b < c) )
{
printf(“%3d + %3d + %3d = %3d\n”,a,b,c,n); // Imprimir no écran os valores
b++; // incrementar b uma unidade
c–; // decrementar c uma unidade
}
a++; // incrementar a uma unidade
b = a + 1; // atribuir o valor de a incrementado de uma unidade a b
c = n-( a + b ); // realizar o cálculo de c para ser validado
} // enquanto se verifique a condição b < c
}
else // não foi digitado um número
{
printf (“\nNão digitou um algarismo ou número!!!”); // Mensagem para o utilizador a informar que não foi digitado um número
}
fflush(stdin); // escreve para o stream indicado qualquer dado armazenado, limpando-o
printf (“\nDeseja continuar? (S/N):”);
do
{
opt = toupper(getchar()); // recebe a entrada digitada e converte-a em maiúscula para facilitar
if ((opt != ‘S’) && (opt != ‘N’)) // caso a entrada não seja S ou N
putch(7); // faz soar o sino
}
while ((opt != ‘S’) && (opt != ‘N’)); // repete a captura da opção enquanto a condição for verdadeira
}
while (opt != ‘N’); // repete o programa enquanto a condição for verdadeira
} // fim da função main
/****************************************************************************************************************/
/******************************************************************************
COPYRIGHT: João Paulino
NAME: dec_somas
PURPOSE: decompor um numero n em somas de 3 parcelas em que a < b < c e
a + b + c = n
REVISIONS:
Ver DATE Author Description
——— ———- ————— ————————————
1.0 João Paulino 1. Created this Program.
NOTES:
OBJECT NAME:
DATE AND TIME:
Username:
******************************************************************************/
#include <stdio.h>
void main(void) // a função main esta declarada assim para gerar contradições com o programadores mais experientes
{ // para não termos warnings (avisos) no compitador colocariamos int main (void) e return 0; antes do fim da função main última }
// declarar a variáveis que armazena o valor introduzido e os valores calculados os quais
// são associados a posições específicas da memória e que possuem um endereço único
// como a própria variável sugere, os valores aí armazenados podem variar ou mudar durante
// o tempo de execução do programa
// cada variável possue um tipo específico, que indica a quantidade de memória que os dados
// aí guardados exigem e que tipo de operações podem sofrer
int n, a, b, c; // declarar variáveis do tipo inteiro n, a, b, c
char opt; // declarar variável para controlo da repetição da execução do programa
do // ciclo que controla a repetição da execução do programa
{
printf (“\nDigite um algarismo ou número e pressione enter:”); // Mensagem para o utilizador digitar um número
if (scanf(“%d”, &n) == 1) // atribuir o valor digitado à variável n e validar se é do tipo inteiro if(valor)==1)
{
a = 1, b = 2, c = n -(a + b); // atribuir os valores iniciais às variáveis
if (b >= c) // verificar a primeira condição b não pode ser igual ou menor do que c
printf(“O inteiro %d digitado não permite aplicar o algoritmo\n “,n); // Mensagem para o utilizador indicando que não é possível aplicar o algoritmo
else // caso se verifique a condição b < c
{
while ( b < c ) // enquanto se verifique a condição b < c
{
for (; b < c; b++, c–) // para complicar colocamos um ciclo for enquanto b < C, incementar b e decrementar C
printf(“%3d + %3d + %3d = %3d\n”,a,b,c,n); // Imprimir no écran os valores
a = a + 1; // incrementar a uma unidade
b = a + 1; // atribuir o valor de a incrementado de uma unidade a b
c = n-( a + b ); // realizar o cálculo de c para ser validado
}
}
}
else // não foi digitado um número
{
printf (“\nNão digitou um algarismo ou número!!!”); // Mensagem para o utilizador a informar que não foi digitado um número
}
fflush(stdin); // escreve para o stream indicado qualquer dado armazenado, limpando-o
printf (“\nDeseja continuar? (S/N):”);
do
{
opt = toupper(getchar()); // recebe a entrada digitada e converte-a em maiúscula para facilitar
if ((opt != ‘S’) && (opt != ‘N’)) // caso a entrada não seja S ou N
putch(7); // faz soar o sino
}
while ((opt != ‘S’) && (opt != ‘N’)); // repete a captura da opção enquanto a condição for verdadeira
}
while (opt != ‘N’); // repete o programa enquanto a condição for verdadeira
} // fim da função main
/****************************************************************************************************************/
/******************************************************************************
COPYRIGHT: João Paulino
NAME: dec_somas
PURPOSE: decompor um numero n em somas de 3 parcelas em que a < b < c e
a + b + c = n
REVISIONS:
Ver DATE Author Description
——— ———- ————— ————————————
1.0 João Paulino 1. Created this Program.
NOTES:
OBJECT NAME:
DATE AND TIME:
Username:
******************************************************************************/
#include <stdio.h>
#include <conio.h>
//#include <ctype.h>
void printADD (int a, int b, int c, int n);
int main(void) // a função main esta declarada assim para gerar contradições com o programadores mais experientes
{ // para não termos warnings (avisos) no compitador colocariamos int main (void) e return 0; antes do fim da função main última }
// declarar a variáveis que armazena o valor introduzido e os valores calculados os quais
// são associados a posições específicas da memória e que possuem um endereço único
// como a própria palafra variável sugere, os valores aí armazenados podem variar ou mudar durante
// o tempo de execução do programa
// cada variável possue um tipo específico, que indica a quantidade de memória que os dados
// aí guardados exigem e que tipo de operações podem sofrer
int n, a, b, c; // declarar variáveis do tipo inteiro n, a, b, c
char opt; // declarar variável para controlo da repetição da execução do programa
do // ciclo que controla a repetição da execução do programa
{
printf (“\nDigite um algarismo ou número e pressione enter:”); // Mensagem para o utilizador digitar um número
if (scanf(“%d”, &n) == 1) // atribuir o valor digitado à variável n e validar se é do tipo inteiro if(valor)==1)
{
a = 1, b = 2, c = n -(a + b); // atribuir os valores iniciais às variáveis
if (b >= c) // verificar a primeira condição b não pode ser igual ou menor do que c
printf(“O inteiro %d digitado não permite aplicar o algoritmo\n “,n); // Mensagem para o utilizador indicando que não é possível aplicar o algoritmo
else // caso se verifique a condição b < c
{
printADD (a, b, c, n);
}
}
else // não foi digitado um número
{
printf (“\nNão digitou um algarismo ou número!!!”); // Mensagem para o utilizador a informar que não foi digitado um número
}
fflush(stdin); // escreve para o stream indicado qualquer dado armazenado, limpando-o
printf (“\nDeseja continuar? (S/N):”);
do
{
opt = toupper(getchar()); // recebe a entrada digitada e converte-a em maiúscula para facilitar
if ((opt != ‘S’) && (opt != ‘N’)) // caso a entrada não seja S ou N
putch(7); // faz soar o sino
}
while ((opt != ‘S’) && (opt != ‘N’)); // repete a captura da opção enquanto a condição for verdadeira
}
while (opt != ‘N’); // repete o programa enquanto a condição for verdadeira
} // fim da função main
void printADD (int a, int b, int c, int n)
{
if (b<c)
{
printf(“%3d + %3d + %3d = %3d\n”,a,b,c,n);
b++;
c=n-(a+b);
printADD (a, b, c, n);
}
else
if (b>=c)
{
a++;
b=a + 1;
c=n-(a+b);
if (b < c)
printADD (a, b, c, n);
}
else return;
}
/****************************************************************************************************************/
João Paulino
