VISUALG3

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

e333cd2b-d35d-4684-9cd8-5762beed535e
VISUALG3/Exemplos/Arquivo.ALG
Algoritmo "arquivo"
// Disciplina : [Linguagem e Lógica de Programação] 
// Professor : Antonio Carlos Nicolodi 
// Descrição : Aqui você descreve o que o programa faz! (função)
// Autor(a) : Nome do(a) aluno(a)
// Data atual : 08/06/2016
Var
// Seção de Declarações das variáveis 
 ARQUIVO "TESTE.TXT"
 Y : CARACTER
 X : INTEIRO
Inicio
// Seção de Comandos, procedimento, funções, operadores, etc... 
 PARA X DE 1 ATE 100
 LEIA(Y)
 ESCREVAL(Y)
 FIMPARA
Fimalgoritmo
VISUALG3/Exemplos/Jogo_velha.alg
Algoritmo "semnome"
// Disciplina: [Linguagem e Lógica de programaçao] 
// Data : 24/4/2015
// Seção de Declarações
var
i,xc,xl : inteiro
l,f : logico
s,x,xcl : caracter
A11,A12,A13,A21,A22,A23,A31,A32,A33 : caracter
Funcao Randomico(Num : inteiro) : Inteiro
VAR
 Ds : Inteiro
Inicio
ECO OFF
Aleatorio on
Aleatorio 1,3
Leia(Ds)
Aleatorio off
Retorne Ds
ECO ON
Fimfuncao
Procedimento Erro
Var
D : Literal
Inicio
Escreval("Campo já está ocupado !!!")
Leia(D)
FimProcedimento
Procedimento Acha_O
Var
Inicio
Enquanto f faca
 xcl <- ""
 i <- 3
 xc <- i
 xcl <- xcl + Numpcarac(i)
 i <- 3
 xl <- i
 xcl <- xcl + Numpcarac(i)
 S <- xcl
 x <- "O"
 se S = "11" entao
 se A11 = "_" entao
 A11 <- X
 f <- Falso
 fimse
 fimse
 se S = "12" entao
 se A12 = "_" entao
 A12 <- X
 f <- Falso
 fimse
 fimse
 se S = "13" entao
 se A13 = "_" entao
 A13 <- X
 f <- Falso
 fimse
 fimse
 se S = "21" entao
 se A21 = "_" entao
 A21 <- X
 f <- Falso
 fimse
 fimse
 se S = "22" entao
 se A22 = "_" entao
 A22 <- X
 f <- Falso
 fimse
 fimse
 se S = "23" entao
 se A23 = "_" entao
 A23 <- X
 f <- Falso
 fimse
 fimse
 se S = "31" entao
 se A31 = "_" entao
 A31 <- X
 f <- Falso
 fimse
 fimse
 se S = "32" entao
 se A32 = "_" entao
 A32 <- X
 f <- Falso
 fimse
 fimse
 se S = "33" entao
 se A33 = "_" entao
 A33 <- X
 f <- Falso
 fimse
 fimse
fimenquanto
Fimprocedimento
Procedimento Mostra_tela
Var
Inicio
 limpatela
 Escreval(" Jogo da Velha em visualG ")
 Escreval(" ")
 Escreval(" ")
 Escreval(" 1 2 3 ")
 Escreval(" +-----+------+------+")
 Escreval("1 | ",A11," | ",A12," | ",A13," |")
 Escreval(" |-----+------+------|")
 Escreval("2 | ",A21," | ",A22," | ",A23," |")
 Escreval(" |-----+------+------|")
 Escreval("3 | ",A31," | ",A32," | ",A33," |")
 Escreval(" |-----+------+------|")
 Escreval(" ")
 Escreval(" ")
 Escreva(" Digite a linha e coluna: ")
FimProcedimento
inicio
// Seção de Comandos
l <- verdadeiro
A11 <- "_"
A12 <- "_"
A13 <- "_"
A21 <- "_"
A22 <- "_"
A23 <- "_"
A31 <- "_"
A32 <- "_"
A33 <- "_"
f <- Falso
enquanto l faca
 f <- (nao f)
 Acha_O
 Mostra_tela
 
 Leia(s)
 SE Compr(S) = 1 entao
 se (S = "F") entao
 l <- Falso
 Interrompa
 fimse
 senao
 SE Compr(S) = 2 entao
 se S = "11" entao
 se A11 = "_" entao
 A11 <- "X"
 senao
 Erro
 fimse
 fimse
 se S = "12" entao
 // A12 <- "X"
 se A12 = "_" entao
 A12 <- "X"
 senao
 Erro
 fimse
 fimse
 se S = "13" entao
 // A13 <- "X"
 se A13 = "_" entao
 A13 <- "X"
 senao
 Erro
 fimse
 fimse
 se S = "21" entao
 // A21 <- "X"
 se A21 = "_" entao
 A21 <- "X"
 senao
 Erro
 fimse
 fimse
 se S = "22" entao
 // A22 <- "X"
 se A22 = "_" entao
 A22 <- "X"
 senao
 Erro
 fimse
 fimse
 se S = "23" entao
 // A23 <- "X"
 se A23 = "_" entao
 A23 <- "X"
 senao
 Erro
 fimse
 fimse
 se S = "31" entao
 // A31 <- "X"
 se A31 = "_" entao
 A31 <- "X"
 senao
 Erro
 fimse
 fimse
 se S = "32" entao
 // A32 <- "X"
 se A32 = "_" entao
 A32 <- "X"
 senao
 Erro
 fimse
 fimse
 se S = "33" entao
 // A33 <- "X"
 se A33 = "_" entao
 A33 <- "X"
 senao
 Erro
 fimse
 fimse
 fimse
 Fimse
 Escreval(" ")
 Escreval(" ")
 Escreval(" ")
 Escreval(" escolha <Ann> ou <Bnn> ou <<F> para finalizar>")
fimenquanto
fimalgoritmo
VISUALG3/Exemplos/CALCULOMEDIA2.ALG
Algoritmo "CalculoMedia2"
// Disciplina: Lógica de programação
// Professor : Antonio Carlos Nicolodi
// Descrição : calculo da média aritimética
// Autor : Professor Antonio
// Data atual: 01/04/2015
var
// Seção de Declarações
 Nota1, Nota2, Nota3, Nota4, Nota5 : Inteiro
 Media: Real
 Aluno : Caracter
Inicio
// Seção dos Comandos
 Escreva ("Digite o nome do aluno: ")
 Leia (Aluno)
 Escreva ("Digite a Primeira nota: ")
 Leia (Nota1)
 Escreva ("Digite a Segunda nota : ")
 Leia (Nota2)
 Escreva ("Digite a Terceira nota: ")
 Leia (Nota3)
 Escreva ("Digite a Quarta nota : ")
 Leia (Nota4)
 Escreva ("Digite a Quint nota : ")
 Leia (Nota5)
 Media <- (Nota1+ Nota2+ Nota3+ Nota4+ Nota5) / 5
 Escreval (" ===================== ")
 Escreval (" ")
 Escreval ("A Média final é: ", Media)
 Escreval (" ")
 Se Media >= 7 entao
 Escreval(" O Aluno ",Aluno, " Passou !")
 Senao
 Escreval(" O Aluno ",Aluno, " Reprovou")
 fimse
Fimalgoritmo
VISUALG3/help/refer.htm
Referências da Linguagem de Programação do
VisuAlg
Nesta página estão todas as palavras-chave da
linguagem de programação do VisuAlg. Em cada uma delas, há um link para
sua correspondente seção dentro das páginas de ajuda.
aleatorio
 algoritmo
 arquivo
 ate
 caractere
 caso
 cronometro
 debug
 e
 eco
 enquanto
 entao
 escolha
 escreva
 escreval
 faca
 falso
 fimalgoritmo
 fimenquanto
 fimescolha
 fimfuncao
 fimpara
 fimprocedimento
 fimrepita
 fimse
 funcao
 inicio
 int
 inteiro
 interrompa
 leia
 limpatela 
 logico
 mod
 nao
 ou
 outrocaso
 para
 passo
 pausa 
 real
 procedimento
 repita
 retorne
 se
 senao
 timer
 var 
 vetor
 verdadeiro
 xou
  Objetivos   
Tela principal    Menu   
A linguagem do VisuAlg   
Referências da linguagem do
VisuAlg   Mais
recursos
VISUALG3/LEIA-ME.txt
Caso você não consiga ver ou não consiga trocar 
a roupagem do programa VISUALG 3.0, FAÇA:
1º Saia ou feche o programa VISUALG 3.0
2º Copie a pasta SKINS para "a unidade C: ou o drive C:" 
 na raiz que deverá ficar assim: C:\SKINS
3º Depois execute o programa novamente e pronto!
Banco do Brasil
Banco: 01
This program is Free. But, if someone wants to make 
a small donation for this project. Others Countries, 
donation (one US dollar) => US$ 1 Thank you !
Brazil Bank, Agency: 3148-8, Checking account:
13.233-0 
=================================================
Este programa é totalmente grátis. 
Porém, para dar continuidade a este PROJETO.
E se alguém puder e quiser ajudá-lo, poderá DOAR 
uma pequena quantia simbólica de : Um Real R$ 1,00 
Banco do Brasil - Agencia: 3148-8 - Cta.-corrente: 13.233-0
Agradeço desde já qualquer ajuda.
VISUALG3/Exemplos/MMC.ALG
Algoritmo "semnome"
// Disciplina : [Linguagem e Lógica de Programação] 
// Professor : Antonio Carlos Nicolodi 
// Descrição : Aqui você descreve o que o programa faz! (função)
// Autor(a) : Nome do(a) aluno(a)
// Data atual : 18/08/2016
Var
// Seção de Declarações das variáveis 
L : LOGICO
n1,n2,R : inteiro
FUNCAO funcMMC(NUM1,NUM2:INTEIRO) : INTEIRO
VAR
 MMC, AUX,I : INTEIRO
INICIO
 PARA I DE 2 ATE NUM2 FACA
 AUX := NUM1 * I
 SE ((AUX MOD NUM2) = 0) ENTAO
 MMC := AUX
// I := NUM2 + 1
 interrompa
 FIMSE
 FIMPARA
 Retorne MMC
FIMFUNCAO
Inicio
// Seção de Comandos, procedimento, funções, operadores, etc... 
N1 := 28
N2 := 40
R := funcMMC(N1,N2)
ESCREVAL("MMC DE ",N1," E ",N2," : ",R)
LEIA(L)
Fimalgoritmo
VISUALG3/Exemplos/DESTAQUES.ALG
Algoritmo "destaques"
// Disciplina : [Linguagem e Lógica de Programação]
// Professor(a): Antonio Carlos Nicolodi
// Descrição : Gerar até 10 números e escolher (qual e qtos) são destaques
// Autor(a) : Eu
// Data atual : 12/09/2015
Var
 // Seção de Declarações das variáveis
 NUMEROS : VETOR[1..10] DE INTEIRO
 REMOVIDO: VETOR[1..10] DE INTEIRO
 INDICE,R1,CONTA,R2,XINS,G1 : INTEIRO
Inicio
 // Seção de Comandos, procedimento, funções, operadores, etc...
MUDACOR("AMARELO","FRENTE")
LIMPATELA
R2 := 0
CONTA := 0
ESCREVAL(" ")
ESCREVAL(" ============================================== ")
ESCREVA("QUANTOS NUMEROS (1-10): ")
LEIA(XINS)
SE XINS <= 10 ENTÃO
 PARA INDICE DE 1 ATÉ XINS FAÇA
 ENQUANTO G1 = 0 FAÇA
 G1 := RANDI(10)
 FIMENQUANTO
 NUMEROS[INDICE] := G1
 G1 := 0
 FIMPARA
 ESCREVA("Digite o destaque: ")
 LEIA(R1)
 PARA INDICE DE 1 ATÉ XINS FAÇA
 SE (NUMEROS[INDICE] = R1) ENTAO
 CONTA := CONTA + 1
 SENÃO
 R2 := R2 + 1
 SE R2 <= XINS ENTÃO
 REMOVIDO[R2] := NUMEROS[INDICE]
 FIMSE
 FIMSE
 FIMPARA
 ESCREVAL(" ")
 ESCREVAL("A SEQUENCIA É ")
 PARA INDICE DE 1 ATÉ XINS FAÇA
 ESCREVA(NUMEROS[INDICE])
 FIMPARA
 ESCREVAL(" ")
 ESCREVAL("O NUMERO DE REPETIÇÕES FOI: ",CONTA)
 ESCREVAL(" ")
 ESCREVAL("RESTOU A SEQUENCIA: ")
 G1 := 0 // REAPROVEITANDO A VARIÁVEL
 PARA INDICE DE 1 ATÉ XINS FAÇA
 G1 := REMOVIDO[INDICE]
 SE G1 <> 0 ENTÃO
 ESCREVA(G1)
 FIMSE
 FIMPARA
FIMSE
Fimalgoritmo
VISUALG3/help/VISUALG30.chm
VISUALG3/help/BARRA_STATUS3_VISUALG3.PNG
VISUALG3/help/botoes_default.bmp
VISUALG3/Exemplos/UDF.ALG
// Disciplina: [Linguagem e Lógica de programaçao] 
// Professor: Antonio Carlos Nicolodi
// Autor : Antonio Carlos Nicolodi
// Data : 20/05/2015 
// funções (não Pré-definas) ou User Define Functions 
// em portugues: Funções Definidas pelo Usuário (programador da linguagem)
// funções e procedimentos UDFs do programa
//
//
// FUNÇÕES GERAIS PARA TODOS OS PROGRAMAS 
// VERIFICA SE EH UM NUMERO E RETORNA VERDADEIRO/FALSO
Funcao E_Num(xString: Caracter) : Logico
Var xpos : Inteiro
 xverd: Logico
 indx : Caracter
Inicio
 se Compr(xString) < 1 entao
 xString := " "
 fimse
 xpos := 0
 xverd := Falso
 indx := "0123456789"
 xpos := POS(xString,indx)
 se xpos > 0 entao
 xverd := Verdadeiro
 fimse
Retorne xverd
Fimfuncao
// Monte uma String com Espacos em branco
Funcao Espaço(xQtde: Inteiro) : Caracter
Var xCar : caracter
 indx : Inteiro
Inicio
 se xQtde < 1 entao
 xQtde := 1
 fimse
 xCar := ""
 Para indx de 1 ate xQtde faca
 xCar := xCar + " "
 Fimpara
Retorne xCar
Fimfuncao
// Replicar varios caracteres numa String com a Qtde
Funcao Replicar(xSTRING : caracter; xQTDE : inteiro) : caracter
 var
 iREP : inteiro
 xREP : caracter
 inicio
 xREP <- ""
 para iREP de 1 ate xQTDE faca
 xREP <- xREP + xSTRING
 fimpara
 Retorne xREP
Fimfuncao
// retorna uma string com caracteres "0" na quantidade passada
Funcao Zeros(xQTDE : inteiro) : caracter
var
 iZER : inteiro
 rZER : Caracter
inicio
 rZER <- ""
 para iZER de 1 ate xQTDE faca
 rZER <- rZER + "0"
 fimpara
 Retorne rZER
Fimfuncao
// retorna uma string c/ todos da Esquerda p/ Direita
Funcao Esquerda(xSTRING : caracter; xQTDE : inteiro) : caracter
var
 iESQ,xESQ : inteiro
 sESQ,cESQ : caracter
inicio
 xESQ <- Compr(cESQ)
 se QTDE > xESQ entao
 QTDE <- xESQ
 fimse
 sESQ <- ""
 para iESQ de 1 ate xESQ faca
 cESQ <- copia(xSTRING,iESQ,1)
 sESQ <- sESQ + cESQ
 xQTDE <- xQTDE - 1
 se QTDE < 1 entao
 interrompa
 fimse
 fimpara
 Retorne sESQ
Fimfuncao
// retorna uma string c/ todos da Direita p/ Esquerda
Funcao Direita(xSTRING : caracter; xQTDE : inteiro) : caracter
var
 iDIR,xDIR : inteiro
 sDIR,cDIR : caracter
inicio
 xDIR <- Compr(xSTRING)
 se xQTDE > xDIR entao
 xQTDE <- xDIR
 fimse
 sDIR <- ""
 para iDIR de xDIR ate 1 passo -1 faca
 cDIR <- copia(xSTRING,iDIR,1)
 sDIR <- cDIR + sDIR
 xQTDE <- xQTDE - 1
 se xQTDE < 1 entao
 interrompa
 fimse
 fimpara
 Retorne sDIR
Fimfuncao
// retorna uma string compactada, retirando os espaços da Esquerda
Funcao Ltrim(xSTRING : caracter) : caracter
var
 iLTR,xLTR : inteiro
 sLTR,cLTR : caracter
inicio
 xLTR <- Compr(xSTRING)
 sLTR <- ""
 iLTR <- 1
 eLTR <- Carac(32)
 cLTR <- copia(xSTRING,iLTR,1)
 Enquanto (cLTR = eLTR) faca
 iLTR <- iLTR + 1
 cLTR <- copia(xSTRING,iLTR,1)
 se iLTR > xLTR entao
 cLTR <- ""
 fimse
 Fimenquanto
 sLTR <- COPIA(xSTRING,iLTR,XLTR)
 Retorne sLTR
Fimfuncao
// retorna uma string compactada, retirando os espaços da Direita
Funcao Rtrim(xSTRING : caracter) : caracter
var
 iRTR,xRTR : inteiro
 sRTR,cRTR : caracter
inicio
 xRTR <- Compr(xSTRING)
 sRTR <- ""
 iRTR <- 1
 eRTR <- Carac(32)
 cRTR <- copia(STRING,xRTR,iRTR)
 Enquanto (cRTR = eRTR) faca
 xRTR <- xRTR - 1
 cRTR <- copia(xSTRING,xRTR,iRTR)
 se xRTR < 1 entao
 cRTR <- ""
 fimse
 Fimenquanto
 sRTR <- COPIA(xSTRING,iRTR,XRTR)
 Retorne sRTR
Fimfuncao
// retorna uma string compactada, retirando os espaços da Direita e da Esq.
Funcao Alltrim(xSTRING : caracter) : caracter
Var
 sALL : caracter
inicio
 sALL <- xSTRING
 sALL <- Ltrim(Rtrim(sALL))
Retorne sALL
Fimfuncao
// retorna um valor lógico se EXPRESSÃO STRINTG ESTÁ CHEIA OU VAZIA.
Funcao Vazia(xSTRING : caracter) : logico
Var
 sVAZ : caracter
 nVAZ : inteiro
 vVAZ : logico
inicio
 vVAZ <- Falso
 sVAZ <- xSTRING
 sVAZ <- Ltrim(Rtrim(sVAZ))
 nVAZ <- Compr(sVAZ)
 se nVAZ = 0 entao
 vVAZ <- Verdadeiro
 fimse
Retorne vVAZ
Fimfuncao
// retorna uma string com caracteres "0" na quantidade passada
Funcao StrZeros(xSTRZERO, xQTDE : inteiro) : caracter
var
 iZER : inteiro
 rZER : Caracter
inicio
 rZER <- ""
 para iZER de 1 ate xQTDE faca
 rZER <- rZER + "0"
 fimpara
 xStrZero <- Direita(rZER
+ ALLTRIM(xStrZero),xQTDE)
 Retorne xStrZero
Fimfuncao
VISUALG3/help/BARRA_VISUALG3_PLASTICO.PNG
VISUALG3/Exemplos/Calculo_media2.alg.ALG
Agoritmo "Calculo_Media2"
// Disciplina: [Linguagem e Lógica de programaçao] 
// Professor: Antonio Carlos Nicolodi
// Função : calculo da média aritimética verificando o resultado for maior ou igual a 7; 
 se Sim mostre o aluno xxxx passou
 se Não mostre o aluno xxxx reprovou 
// Autor : Professor Antonio
// Data : 05/04/2015
// Seção de Declarações
var
 Nota1, Nota2, Nota3, Nota4, Nota5, Media: Real
 Aluno : Caracter
Inicio
// Seção de Comandos
Escreva ("Digite o nome do aluno: ")
 Leia (Aluno)
Escreva ("Digite a Primeira nota: ")
 Leia (Nota1)
 Escreva ("Digite a Segunda nota: ")
 Leia (Nota2)
 Escreva ("Digite a Terceira nota: ")
 Leia (Nota3)
Escreva ("Digite a Quarta nota: ")
 Leia (Nota4)
Media <- (Nota1+ Nota2+ Nota3+ Nota4+ Nota5) / 5
 Escreva ("A Média eh: ", Media)
Se Media >=7 entao
 Escreva(" O Aluno ",Aluno, "Passou")
Senao
 Escreva(" O Aluno ",Aluno, "Reprovou")
fimse
Fimalgoritmo
VISUALG3/Exemplos/TABOADA.ALG
Algoritmo "Taboada de n"
// Disciplina : [Linguagem e Lógica de programaçao]
// Professor(a): Antonio Carlos Nicolodi
// Descrição : Esse programa mostra a Taboada de "numero" ...
// Autor(a) : Nome do(a) aluno(a) [Antonio...]
// Data atual : 22/06/2015
var
// Seção de Declarações das variáveis 
 indice, numero : INTEIRO
inicio
// Seção de Comandos, procedimento, funções, operadores, etc... 
 LIMPATELA
 ESCREVAL(" ")
 ESCREVA("Digite um número : ")
 LEIA(X)
 ESCREVAL(" TABOADA DE NOVE (",X:2,") ")
 PARA Indice DE 1 ATÉ 10 FAÇA
 ESCREVAL(i," X ",numero," = ",i * numero)
 FIMPARA
 
fimalgoritmo
VISUALG3/Exemplos/MODULO.ALG
Algoritmo "Modulo"
// Disciplna : [Linguagem e Lógica de Programação] 
// Professor : Antonio Carlos Nicolodi 
// Descrição : Aqui você descreve o que o programa faz! (função)
// Autor(a) : Nome do(a) aluno(a)
// Data atual : 12/12/2015
Var
// Seção de Declarações das variáveis 
x,r : real
a,b : inteiro
m : Inteiro
Inicio
// Seção de Comandos, procedimento, funções, operadores, etc... 
 Escreval("digite modulo ")
 Leia(m)
 Escreval("digite x ")
 Leia(x)
 r := (X % m)
 SE r=0 ENTAO
 ESCREVAL("MULTIPLO",r)
 SENAO
 ESCREVAL("N/ MULTIPLO",r)
 FIMSE
 Escreval("digite A ")
 Leia(a)
 b := (a % m)
 SE b=0 ENTAO
 ESCREVAL("MULTIPLO",b)
 SENAO
 ESCREVAL("N/ MULTIPLO",b)
 FIMSE
Fimalgoritmo
FIMSE
VISUALG3/help/help.chm
VISUALG3/Exemplos/EXTENSO4.ALG
algoritmo "Extenso4"
// Disciplina: [Linguagem e Lógica de programaçao] 
// Professor: Antonio Carlos Nicolodi
// Função: Calcula os passos de um caracol para subir o poço
// Autor : Antonio Carlos Nicolodi
// Data : 20/04/2015 
var
 ate20: vetor[1..19] de literal
 dezena: vetor[1..9] de literal
 centena: vetor[1..9] de literal
 Milhar: vetor[1..3] de literal
 XPARTES: vetor[1..4] de literal
 MONTAGEM, XPRIM, XSECN, XTERC, XDECIMAL, STRING: Caracter
 xval, i, x, valor, XCOMPt: Inteiro
inicio
 Textos <- ""
 Escreva("Informe o valor: ")
 leia (valor)
 STRING := NUMPCARAC(VALOR)
 XCOMPt := COMPR(VALOR)
 XVAL := 11 - XCOMPt
 xdecimal := DECIMAL(STRING)
 STRING := ESPACO(XVAL)+STRING
 MONTAGEM := ""
 XPRIM := COPIA(STRING,1,3) // CENTENAS/DEZENA/UNIDADE DE MILHOES
 XSECN := COPIA(STRING,1,3) // CENTENAS/DEZENA/UNIDADE DE MILHARES
 XTERC := COPIA(STRING,1,3) // CENTENAS/DEZENA/UNIDADE DE UNIDADE
 
 xPARTES[1] := XPRIM
 xPARTES[2] := XSECN
 xPARTES[3] := XTERC
 xPARTES[4] := XDECIMAL
 PARA I DE 1 TO 4 FACA
 SE (nao Vazio(xprim)) entao
 X := 1
 ENQUANTO (X < 4) FACA
 CAR := COPIA(XPRIM,X,1)
 Escolha X
 Caso 1:
 SE (E_NUM(CAR) E (X = 1)) ENTAO
 Ccc := CaracpNum(Car)
 Car := Centena[Ccc]
 FIMSE
 Montagem1 := Montagem1 + Car
 X := X + 1
 FIMENQUANTO
 Escreval(Textos)
fimalgoritmo
 
 
// FUNCOES GERAIS
Funcao Vazia(STRING : caracter) : logico
Var
 sVAZ : caracter
 nVAZ : inteiro
 vVAZ : logico
inicio
 vVAZ <- Falso
 sVAZ <- STRING
 sVAZ <- Ltrim(Rtrim(sVAZ))
 nVAZ <- Compr(sVAZ)
 se nVAZ = 0 entao
 vVAZ <- Verdadeiro
 fimse
Retorne vVAZ
Fimfuncao
Funcao E_Num(String: Caracter) : Logico
Var xpos : Inteiro
 xverd: Logico
 indx : Caracter
Inicio
 se Compr(String) < 1 entao
 String := " "
 fimse
 xpos := 0
 xverd := Falso
 indx := "0123456789"
 xpos := POS(String,indx)
 se xpos > 0 entao
 xverd := Verdadeiro
 fimse
Retorne xverd
Fimfuncao
//
Funcao Espaco(Qtde: Inteiro) : Caracter
Var xCar : caracter
 indx : Inteiro
Inicio
 se Qtde < 1 entao
 Qtde := 1
 fimse
 xCar := ""
 Para indx de 1 ate Qtde faca
 xCar := xCar + " "
 Fimpara
Retorne xCar
Fimfuncao
Funcao Decimal(Valor: Caracter) : Caracter
Var xCar, xRET : caracter
 indx : Inteiro
 R_Valor, R_V: Real
Inicio
 se Vazio(Valor) entao
 XRET := "00"
 fimse
 xCar := ""
 R_valor := CaracpNum(Valor)
 indx := Int(R_valor)
 R_v := Int(((R_valor - indx)+0.001)*100)/100
 xRet := NumpCarac(R_v)
Retorne xRet
Fimfuncao
// FUNCAO EXCLUSIVA DESSE PROGRAMA
Funcao AbaixoMil(Valor: Real ) : Caracter
Var
 xcomp : inteiro
 xtext_vazio : Logico
Inicio
 xtext_vazio <- Falso
 Val <- Int(Valor)
 xcomp <- compr(Textos)
 se xcomp = 0 entao
 xtext_vazio <- Verdadeiro
 fimse
 se val = 0 entao
 se nao MaiorQ entao
 Textos <- "Zero"
 fimse
 senao
 se ((Val > 0) e (val < 20)) entao
 se val = 1 entao
 se nao MaiorQ entao
 Textos <- "Hum"
 senao
 se nao xtext_vazio entao
 Textos <- Textos+" e um"
 senao
 Textos <- " um"
 fimse
 fimse
 senao
 se nao xtext_vazio entao
 Textos <- Textos + " e " + ate20[val]
 senao
 Textos <- ate20[val]
 fimse
 val <- p - val
 fimse
 senao
 se (val < 100) entao
 i <- Int(val / 10)
 Textos <- Textos + dezena[i]
 val <- Int(val % 10)
 se (val > 0) entao
 se nao xtext_vazio entao
 Textos <- Textos + " e " + ate20[val]
 senao
 Textos <- ate20[val]
 fimse
 fimse
 senao
 se (val = 100) entao
 Textos <- "Cem"
 senao
 i <- Int(val / 100)
 se i > 0 entao
 Textos <- centena[i]
 xmul <- Int(val - (i * 100))
 val <- xmul
 i <- Int(val / 10)
 se i > 0 entao
 xmul <- Int(val - (i * 10))
 se nao xtext_vazio entao
 Textos <- Textos + " e " + ate20[val]
 senao
 Textos <- ate20[val]
 fimse
 val <- xmul
 se (val > 0) entao
 se nao xtext_vazio entao
 Textos <- Textos + " e " + ate20[val]
 senao
 Textos <- ate20[val]
 fimse
 fimse
fimse
 fimse
 fimse
 fimse
 fimse
 fimse
Retorne Textos
Fimfuncao
// ate20[0] <- "zero"
 ate20[1] <- "um"
 ate20[2] <- "dois"
 ate20[3] <- "três"
 ate20[4] <- "quatro"
 ate20[5] <- "cinco"
 ate20[6] <- "seis"
 ate20[7] <- "sete"
 ate20[8] <- "oito"
 ate20[9] <- "nove"
 ate20[10] <- "dez"
 ate20[11] <- "onze"
 ate20[12] <- "doze"
 ate20[13] <- "treze"
 ate20[14] <- "quatorze"
 ate20[15] <- "quinze"
 ate20[16] <- "dezesseis"
 ate20[17] <- "dezessete"
 ate20[18] <- "dezoito"
 ate20[19] <- "dezenove"
 dezena[1] <- "dez"
 dezena[2] <- "vinte"
 dezena[3] <- "trinta"
 dezena[4] <- "quarenta"
 dezena[5] <- "cinquenta"
 dezena[6] <- "sessenta"
 dezena[7] <- "setenta"
 dezena[8] <- "oitenta"
 dezena[9] <- "noventa"
 centena[1] <- "Cento"
 centena[2] <- "Duzentos"
 centena[3] <- "trezentos
 centena[4] <- "quatrocentos"
 centena[5] <- "quinhentos"
 centena[6] <- "seiscentos"
 centena[7] <- "setecentos"
 centena[8] <- "oitocentos"
 centena[9] <- "novecentos"
// CENTAVOS ,99
 Milhar[1] <- "mil" // 999
 Milhar[2] <- "milhão" // 999.999
 Milhar[3] <- "Bilhão" // 999.999.999
VISUALG3/Exemplos/Recursividade1.alg
Algoritmo "semnome"
// Disciplina : [Linguagem e Lógica de Programação] 
// Professor : Antonio Carlos Nicolodi 
// Descrição : mostra uma variação de V = V . (V-1)
// Autor(a) : Nome do(a) aluno(a)
// Data atual : 28/02/2016
Var
// Seção de Declarações das variáveis 
 X,I: inteiro
 V: VETOR[0..10] DE inteiro
Inicio
// Seção de Comandos, procedimento, funções, operadores, etc... 
 PARA I DE 10 ATÉ 0 PASSO -1 FAÇA
 V[I] <- I
 FIMPARA
 PARA I DE 10 ATÉ 0 PASSO -1 FAÇA
 SE ((I - 1) >= 0) ENTÃO
 X <- V[I] * V[I-1]
 ESCREVAL(I:2," = ",X:2)
 FIMSE
 FIMPARA
Fimalgoritmo
VISUALG3/Exemplos/OSPARES.ALG
Algoritmo "OSPARES"
// Disciplina : [Linguagem e Lógica de Programação] 
// Professor(a): Antonio Carlos Nicolodi 
// Descrição : Aqui você descreve o que o programa faz! (função)
// Autor(a) : Nome do(a) aluno(a)
// Data atual : 11/07/2015
Var
// Seção de Declarações das variáveis 
n1 : inteiro
FUNÇÃO Pares(x: Inteiro) : Logico
Inicio
 SE (X MOD 2) = 0 ENTÃO
 Retorne Verdadeiro
 SENÃO
 Retorne FALSO
 FIMSE
 
FIMFUNÇÃO
Inicio
// Seção de Comandos, procedimento, funções, operadores, etc... 
 PARA n1 de 360 ATÉ 0 PASSO -13 FAÇA
 SE Pares(n1) ENTÃO
 ESCREVAL(n1)
 FIMSE
 FIMPARA
Fimalgoritmo
VISUALG3/Exemplos/MENU_PRINCIPAL.alg
Algoritmo "semnome"
// Disciplina : [Linguagem e Lógica de Programação]
// Professor(a): Antonio Carlos Nicolodi
// Descrição : Aqui você descreve o que o programa faz! (função)
// Autor(a) : Nome do(a) aluno(a)
// Data atual : 15/09/2015
Var
 // Seção de Declarações das variáveis
 numero : vetor[1..5] de inteiro
 NOME : vetor[1..5] de Caracter
 IDADE : vetor[1..5] de caracter
 indice : inteiro
 L,XL : LOGICO
 OPCAO : Caracter
 
FUNÇÃO PESQUISA(XV: INTEIRO) : LOGICO
VAR II : INTEIRO
 A : LOGICO
INICIO
 A := FALSO
 PARA II DE 1 ATÉ 5 FAÇA
 SE numero[ii] = xv ENTÃO
 A := VERDADEIRO
 interrompa
 FIMSE
 FIMPARA
 RETORNE A
FIMFUNÇÃO
PROCEDIMENTO INCLUIR
VAR II : INTEIRO
 L : LOGICO
 xnum : INTEIRO
 xnom : caracter
 xidd : caracter
INICIO
 limpaTela
 Escreval(" INCLUIR ")
 SE indice <= 5 ENTÃO
 xnum := 0
 Xnom := ""
 xidd := ""
 L := VERDADEIRO
 ENQUANTO L FAÇA
 ESCREVA("DIGITE O NUMERO",Indice," : ")
 LEIA(xnum)
 L := PESQUISA(xnum)
 FIMENQUANTO
 ESCREVA("DIGITE o Nome : ")
 LEIA(xnom)
 ESCREVA("DIGITE a Idade: ")
 LEIA(xidd)
 Numero[indice] := xnum
 Nome[indice] := xnom
 Idade[indice] := xidd
 indice := indice + 1
 FIMSE
 ESCREVAL(" ")
 ESCREVA("TECLE <ENTER> ")
 LEIA(XL)
FIMPROCEDIMENTO
PROCEDIMENTO CONSULTAR
VAR II : INTEIRO
 L : LOGICO
 xnum : INTEIRO
 xnom : caracter
 xidd : caracter
INICIO
 limpaTela
 Escreval(" CONSULTA ")
 PARA II DE 1 ATÉ 5 FAÇA
 ESCREVAL("[",II,"] -> ",NUMERO[II]," ",NOME[II]," ",IDADE[II])
 FIMPARA
 ESCREVAL(" ")
 ESCREVA("TECLE <ENTER> ")
 LEIA(XL)
FIMPROCEDIMENTO
PROCEDIMENTO EXCLUIR
VAR II : INTEIRO
 L : LOGICO
 xnum : INTEIRO
 xnom : caracter
 xidd : caracter
INICIO
 limpaTela
 Escreval(" EXCLUIR ")
 xnum := 0
 L := FALSO
 ENQUANTO L FAÇA
 ESCREVA("DIGITE O NUMERO ",II," : ")
 LEIA(xnum)
 L := PESQUISA(xnum)
 FIMENQUANTO
 ESCREVAL("DIGITE o Nome : ",Nome[ii])
 ESCREVAL("DIGITE a Idade: ",Idade[ii])
 Nome[ii] := " "
 Idade[ii]:= " "
 ESCREVAL(" ")
 ESCREVA("TECLE <ENTER> ")
 LEIA(XL)
FIMPROCEDIMENTO
PROCEDIMENTO ALTERAR
VAR II : INTEIRO
 L : LOGICO
 xnum : INTEIRO
 xnom : caracter
 xidd : caracter
INICIO
 limpaTela
 Escreval(" ALTERAÇÃO ")
 xnum := 0
 Xnom := ""
 xidd := ""
 L := Falso
 ENQUANTO L FAÇA
 ESCREVA("DIGITE O NUMERO : ")
 LEIA(xnum)
 L := PESQUISA(xnum)
 FIMENQUANTO
 ESCREVAL("DIGITE o Nome : ",Nome[ii])
 ESCREVAL("DIGITE a Idade: ",Idade[ii])
 ESCREVA("DIGITE o Nome : ")
 LEIA(xnom)
 ESCREVA("DIGITE a Idade: ")
 LEIA(xidd)
 Numero[II] := xnum
 Nome[ii] := xnom
 Idade[ii] := xidd
 ESCREVAL(" ")
 ESCREVA("TECLE <ENTER> ")
 LEIA(YL)
FIMPROCEDIMENTO
Inicio
 indice := 1
 L := VERDADEIRO
 OPCAO := ""
 ENQUANTO L FAÇA
 LIMPATELA
 ESCREVAL(" MENU ")
 ESCREVAL("1-INCLUSÃO")
 ESCREVAL("2-CONSULTA")
 ESCREVAL("3-EXCLUSÃO")
 ESCREVAL("4-ALTERAÇÃO")
 ESCREVAL("5-FINALIZAR")
 ESCREVAL(" ")
 Escreva("Digite a opção:")
 Leia(opcao)
 ESCOLHA OPCAO FAÇA
 CASO "1"
 INCLUIR
 CASO "2"
 CONSULTAR
 CASO "3"
 EXCLUIR
 CASO "4"
 ALTERAR
 CASO "5"
 L := FALSO
 OUTROCASO
 ESCREVAL("OPÇÃO INVÁLIDA !!!")
 ESCREVAL(" ")
 ESCREVA("TECLE <ENTER> ")
 LEIA(XL)
 FIMESCOLHA
 FIMENQUANTO
Fimalgoritmo
VISUALG3/help/Principal_arquivos/image003.jpg
VISUALG3/help/linguagem2.htm
A Linguagem de Programação do VisuAlg (2)
Operadores Aritméticos
			+,-			Operadores unários, isto é,
 são aplicados a um único operando. São os operadores aritméticos de
 maior precedência. Exemplos: -3,
 +x. Enquanto o operador unário -
 inverte o sinal do seu operando, o operador +
 não altera o valor em nada o seu valor.
			\ 			Operador
de divisão inteira. Por exemplo, 5 \ 2 = 2. Tem a mesma precedência do
operador de divisão tradicional.
			+,-,*,/ 			Operadores
aritméticos tradicionais de adição, subtração, multiplicação e
divisão. Por convenção, * e
 / têm precedência sobre
 +
e -. Para modificar a ordem de
avaliação das operações, é necessário usar
parênteses como em qualquer expressão aritmética.
			MOD ou %			Operador de módulo (isto é, resto 
 da divisão inteira). Por exemplo, 8 
 MOD 3 = 2. Tem a mesma precedência do operador de divisão tradicional.
			^ 			Operador
de potenciação. Por exemplo, 5 ^ 2 = 25. Tem a maior precedência entre os
operadores aritméticos binários (aqueles que têm dois operandos).
Operadores de Caracteres
			+ 			Operador de concatenação de
 strings (isto é, cadeias de caracteres), quando
usado com dois
valores (variáveis ou constantes) do tipo "caractere". Por exemplo: "Rio
" + " de Janeiro" = "Rio de Janeiro".
Operadores Relacionais
			=, <, >, <=, >=, <>  			Respectivamente: igual,
menor que, maior
que, menor ou igual a, maior ou igual a, diferente de. São utilizados em
expressões lógicas para se testar a relação entre dois valores do mesmo tipo.
Exemplos: 3 = 3
( 3 é igual a 3?) resulta em VERDADEIRO
; "A" > "B"
("A" está depois de "B" na ordem alfabética?) resulta
em FALSO.
Importante: No VisuAlg, as comparações
entre strings não diferenciam as letras maiúsculas das minúsculas. Assim, "ABC"
é igual a "abc".
Valores lógicos obedecem à seguinte ordem:
FALSO < VERDADEIRO.
Operadores Lógicos
			nao 			Operador
unário de negação. nao VERDADEIRO =
FALSO, e nao
FALSO = VERDADEIRO. Tem a maior precedência
entre os operadores lógicos. Equivale ao 
NOT do Pascal.
			ou 			Operador
que resulta VERDADEIRO
quando um dos seus operandos lógicos for verdadeiro. Equivale ao 
OR do Pascal.
			e 			Operador que resulta
VERDADEIRO
somente se seus dois operandos lógicos forem verdadeiros. Equivale ao 
AND do Pascal.
			xou			Operador
que resulta VERDADEIRO
se seus dois operandos lógicos forem diferentes, e FALSO
se forem iguais. Equivale ao XOR
do Pascal.
Comandos de Saída de Dados
escreva (<lista-de-expressões>)
Escreve no dispositivo de
saída padrão (isto é, na área à direita da metade inferior da tela do VisuAlg) o
conteúdo de cada uma das expressões que compõem <lista-de-expressões>. 
As expressões dentro desta lista devem estar separadas por vírgulas; depois de
serem avaliadas, seus resultados são impressos na ordem indicada. É
equivalente ao comando write
do Pascal.
De modo semelhante a Pascal, é possível especificar o número de espaços no
qual se deseja escrever um determinado valor. Por exemplo, o comando escreva(x:5)
escreve o valor da variável x
em 5 espaços, alinhado-o à direita. Para variáveis reais, pode-se também
especificar o número de casas fracionárias que serão exibidas. Por exemplo,
considerando y
como uma variável real, o comando escreva(y:6:2)escreve seu valor em 6
espaços colocando 2 casas decimais. 
escreval (<lista-de-expressões>). 
Idem ao anterior, com a única diferença que pula uma linha em seguida. É
equivalente ao writeln
do Pascal.
 Exemplos:
 algoritmo "exemplo"
 var x: real
     y: inteiro
     a: caractere
     l: logico
 inicio
 x <- 2.5
 y <- 6
 a <- "teste"
 l <- VERDADEIRO
 escreval ("x", x:4:1, y+3:4) // Escreve: x 2.5    9
 escreval (a, "ok")          
 // Escreve: testeok (e depois pula linha)
 escreval (a, " ok")          // Escreve: teste ok (e depois pula linha)
 escreval (a + " ok")         // Escreve: teste ok (e depois pula linha)
 escreva (l)                 
 // Escreve: VERDADEIRO
 fimalgoritmo
Note que o VisuAlg separa expressões do tipo
numérico e lógico com um espaço à esquerda, mas não as expressões do tipo caractere, para
que assim possa haver a concatenação. Quando se deseja separar expressões
do tipo caractere, é necessário acrescentar espaços nos locais adequados.
Comando de Entrada de Dados
leia (<lista-de-variáveis>)
Recebe valores digitados pelos usuário, atribuindo-os às
variáveis cujos nomes estão em <lista-de-variáveis>
(é respeitada a ordem especificada nesta lista). É análogo ao comando read
do Pascal.
 Veja no
exemplo abaixo o resultado:
algoritmo "exemplo 1"
var x: inteiro;
inicio
leia (x)
escreva (x)
fimalgoritmo
O comando de leitura acima irá exibir uma janela
como a que se vê ao lado, com a mensagem padrão:
 "Entre com o valor de <nome-de-variável>"
 
Se você clicar em Cancelar ou teclar Esc durante
a leitura de dados, o programa será imediatamente interrompido.
Comando de Desvio Condicional
se <expressão-lógica>
entao
    <seqüência-de-comandos>
fimse
Ao encontrar este comando, o VisuAlg analisa a <expressão-lógica>. Se o seu
resultado for VERDADEIRO,
todos os comandos da <seqüência-de-comandos>
(entre esta linha e a linha com fimse)
são executados. Se o resultado for FALSO,
estes comandos são desprezados e a execução do algoritmo continua a partir
da primeira linha depois do fimse.
se <expressão-lógica>
entao
    <seqüência-de-comandos-1>
senao
    <seqüência-de-comandos-2>
fimse
Nesta outra forma do comando, se o resultado da
avaliação de <expressão-lógica>
for VERDADEIRO,
todos os comandos da <seqüência-de-comandos-1>
(entre esta linha e a linha com senao)
são executados, e a execução continua depois a partir da primeira linha
depois do fimse.
Se o resultado for FALSO,
estes comandos são desprezados e o algoritmo continua a ser executado a partir
da primeira linha depois do senao,
executando todos os comandos da <seqüência-de-comandos-2>
(até a linha com fimse).
Estes comandos equivalem ao if...then e if...then...else do
Pascal. Note que não há necessidade de delimitadores de bloco (como begin
e end),
pois as seqüências de comandos já estão delimitadas pelas palavras-chave senao
e fimse.
O VisuAlg permite o aninhamento desses comandos de desvio condicional.
Comando de Seleção
Múltipla
O VisuAlg implementa (com certas variações) o
comando case
do Pascal. A sintaxe é a seguinte:
escolha <expressão-de-seleção>
caso <exp11>, <exp12>, ..., <exp1n>
   <seqüência-de-comandos-1>
caso <exp21>, <exp22>, ..., <exp2n>
   <seqüência-de-comandos-2>
...
outrocaso
   <seqüência-de-comandos-extra>
fimescolha
Veja o exemplo a seguir, que ilustra bem o que
faz este comando:
algoritmo "Times"
var time: caractere
inicio
escreva ("Entre com o nome de um time de futebol: ")
leia (time)
escolha time
caso "Flamengo", "Fluminense", "Vasco", "Botafogo"
   escreval ("É um time carioca.")
caso "São Paulo", "Palmeiras", "Santos", "Corínthians"
   escreval ("É um time paulista.")
outrocaso
   escreval ("É de outro estado.")
fimescolha
fimalgoritmo
 
Anterior Próxima
  Objetivos   
Tela principal    Menu   
A linguagem do VisuAlg   
Referências da linguagem do VisuAlg   Mais
recursos
VISUALG3/visualg30.ini
[Files]
MRUFile1=C:\Documents and Settings\USUARIO\Desktop\VALOREXTENSO.ALG
MRUFile2=C:\Documents and Settings\USUARIO\Desktop\ORDENACAO.alg
MRUFile3=C:\VISUALG3\Exemplos\MENU_COM_CASE.alg
MRUFile4=C:\Documents and Settings\USUARIO\Desktop\MEDIA.alg
MRUFile5=C:\Documents and Settings\USUARIO\Desktop\VISUALG\VISUALG3\Exemplos\CARACOL.ALG
[Editor]
CommentAttri=2
CommentColor=32768
IdentifierAttri=1
IdentifierColor=0
StringAttri=0
StringColor=255
TiposDedadosAttri=4
TiposDeDadosColor=128
ConstantesAttri=0
ConstantesColor=255
EspecialAttri=4
EspecialColor=16711680
NumberAttri=0
NumberColor=255
TabWidth=3
Color=16777215
FontName=Courier New
FontSize=11
SmartTabs=1
KeyAttri=0
KeyColor=10485760
SkinName=4
[Email]
NumEmails=0
Email1=
NumServers=2
Server1=
Email2=
Server2=
[Personal]
Entidade=CEDUPHH - Centro de Educação Profissional Herman Hering de Blumenau/SC
Disciplina=Disciplina : [Linguagem e Lógica de Programação] 
Professor=Professor : Antonio Carlos Nicolodi
Turma=
Endlinha1=Rua Benjamin Constant, 857 - Cep: 89037501 
Endlinha2=Escola Agricola 
Endlinha3=Blumenau - SC 
Endlinha4=Telefone: (47) 3327-0866
Endlinha5=
Endlinha6=
VISUALG3/Exemplos/VALOREXTENSO.ALG
Algoritmo "ValorExtensoA1"
// Disciplina : [Lógica de Programação]
// Função : Escreve um valor monetário por extenso.
// Autores : Antonio e Mário Leite
//E-mails : marleite@gmail.com
e professor.antonio.nicolodi@gmail.com
//------------------------------------------------------------------------------------
Var ValorNum: real
 ValorExt: caractere
// retorna uma string c/ todos da Direita p/ Esquerda
Funcao Direita(STRING : caracter; QTDE : inteiro) : caracter
var
 iDIR,xDIR : inteiro
 sDIR,cDIR : caracter
inicio
 xDIR <- Compr(STRING)
 se QTDE > xDIR entao
 QTDE <- xDIR
 fimse
 sDIR <- ""
 para iDIR de xDIR ate 1 passo -1 faca
 cDIR <- copia(STRING,iDIR,1)
 sDIR <- cDIR + sDIR
 QTDE <- QTDE - 1
 se QTDE < 1 entao
 interrompa
 fimse
 fimpara
 Retorne sDIR
Fimfuncao
// retorna uma string com a quantidade [QTDE] de ZEROS ex. 00000000
Funcao Zeros(QTDE : inteiro) : caracter
var
 iZER : inteiro
 rZER : Caracter
inicio
 rZER <- ""
 para iZER de 1 ate QTDE faca
 rZER <- rZER + "0"
 fimpara
 Retorne rZER
Fimfuncao
// retorna uma string retirando os espaços da Esquerda para a direita
Funcao Ltrim(xSTRING : caracter) : caracter
var
 iLTR,xLTR : inteiro
 sLTR,cLTR, ELTR : caracter
inicio
 xLTR <- Compr(xSTRING)
 sLTR <- ""
 iLTR <- 1
 eLTR <- Carac(32)
 cLTR <- copia(xSTRING,iLTR,1)
 Enquanto (cLTR = eLTR) faca
 iLTR <- iLTR + 1
 cLTR <- copia(xSTRING,iLTR,1)
 se iLTR > xLTR entao
 cLTR <- ""
 fimse
 Fimenquanto
 sLTR <- COPIA(xSTRING,iLTR,XLTR)
 Retorne sLTR
Fimfuncao
Funcao MASCARA(MVALOR: REAL) : CARACTER
VAR
 MPARTE_I,MC : INTEIRO
 MCENTAVO : REAL
 MTEXTO,MTEMP,MCENT1,MCENT2 : CARACTER
INICIO
 MPARTE_I <- INT(MVALOR) // RETIRE A PARTE INTEIRA
 MCENTAVO <- (MVALOR - MPARTE_I) * 100
 MC <- INT(MCENTAVO+0.50)
 MCENT1 <- NUMPCARAC(MC)
 MCENT2 <- ZEROS(2-COMPR(MCENT1))+MCENT1
 MTEMP <- NUMPCARAC(MPARTE_I)+"."+MCENT2
 MTEXTO <- ZEROS(9-COMPR(MTEXTO))+MTEMP // PREENCHA C/ ZEROS
 MTEXTO <- DIREITA(MTEXTO,12) // PEGUE OS 12 CAR. DA MASCARA
 RETORNE MTEXTO
FIMFUNCAO
// =============================================================
Funcao ValorPorExtenso(QVALOR:REAL): CARACTER
// =============================================================
VAR
 A : VETOR[0..9] DE CARACTER
 B : VETOR[1..19] DE CARACTER
 C : VETOR[1..9] DE CARACTER
 V : VETOR[1..4] DE CARACTER
 MOEDAS: VETOR[1..4] DE CARACTER
 VALOR, EXT, V1, V2, V3, V4 : CARACTER
 P, ST1, ST2, ST3, STG, CT, E100 : INTEIRO
 VA, CONEC, EXT1, TEXTO : CARACTER
INICIO
 VALOR <- MASCARA(QVALOR) // RETORNA NO FORMATO
 SE (QVALOR >= 0.01) E (QVALOR <= 999999999.99) ENTAO
 MOEDAS[1] := "Real"
 MOEDAS[2] := "Reais"
 MOEDAS[3] := "Centavo"
 MOEDAS[4] := "Centavos"
 EXT <- " "
 A[0] <- "Cento"
 A[1] <- "Cem"
 A[2] <- "Duzentos"
 A[3] <- "Trezentos"
 A[4] <- "Quatrocentos"
 A[5] <- "Quinhentos"
 A[6] <- "Seiscentos"
 A[7] <- "Setecentos"
 A[8] <- "Oitocentos"
 A[9] <- "Novecentos"
 B[1] <- "Um"
 B[2] <- "Dois"
 B[3] <- "Tres"
 B[4] <- "Quatro"
 B[5] <- "Cinco"
 B[6] <- "Seis"
 B[7] <- "Sete"
 B[8] <- "Oito"
 B[9] <- "Nove"
 B[10]<- "Dez"
 B[11]<- "Onze"
 B[12]<- "Doze"
 B[13]<- "Treze"
 B[14]<- "Quatorze"
 B[15]<- "Quinze"
 B[16]<- "Dezesseis"
 B[17]<- "Dezesete"
 B[18]<- "Dezoito"
 B[19]<- "Dezenove"
 C[1] <- "Dez"
 C[2] <- "Vinte"
 C[3] <- "Trinta"
 C[4] <- "Quarenta"
 C[5] <- "Cinquenta"
 C[6] <- "Sessenta"
 C[7] <- "Setenta"
 C[8] <- "Oitenta"
 C[9] <- "Noventa"
 P <- 1
 STG<- 0
 V[1] <- COPIA(VALOR,1,3) // 999
 V[2] <- COPIA(VALOR,4,3) // 999
 V[3] <- COPIA(VALOR,7,3) // 999
 V[4] <- " "+COPIA(VALOR,11,2) // 99
 PARA P DE 1 ATE 4 FACA
 ST1 <- 0
 ST2 <- 0
 ST3 <- 0
 VA <- V[P]
 CT <- 1
 ENQUANTO CARACPNUM(COPIA( VA,1,1)) <> 0 FACA
 SE CARACPNUM(COPIA( VA,1,1)) = CT ENTAO
 SE (STG = 1) ENTAO
 // SE (P <> 4) ENTAO
 // CONEC <- ", "
 // SENAO
 CONEC <- " E "
 // FIMSE
 FIMSE
 EXT1 <- A[CT]
 SE (CARACPNUM(COPIA(VA,1,1)) = 1) E (CARACPNUM(COPIA( VA,2,2)) <> 0) ENTAO
 EXT1 <- A[0]
 FIMSE
 SE (STG = 0) ENTAO
 EXT <- EXT + EXT1
 SENAO
 EXT <- EXT + CONEC + EXT1
 FIMSE
 ST1 <- 1
 INTERROMPA
 FIMSE
 CT <- CT + 1
 SE (CT = 10) ENTAO
 INTERROMPA
 FIMSE
 FIMENQUANTO
 CT <- 2
 ENQUANTO ( CARACPNUM(COPIA( VA,2,1)) <> 0) E (CARACPNUM(COPIA( VA,2,1)) <> 1) FACA
 SE (CARACPNUM(COPIA(VA,2,1)) = CT) ENTAO
 EXT1 <- C[CT]
 SE ((ST1 = 0) E (STG=0)) ENTAO
 EXT <- EXT + EXT1
 SENAO
 EXT <- EXT + " E " + EXT1
 FIMSE
 ST2 <- 1
 INTERROMPA
 FIMSE
 CT <- CT + 1
 SE (CT = 10) ENTAO
 INTERROMPA
 FIMSE
 FIMENQUANTO
 CT <- 1
 ENQUANTO (CARACPNUM(COPIA(VA,2,1)) = 1) FACA
 SE (CARACPNUM(COPIA(VA,2,2)) = CT) ENTAO
 EXT1 <- B[CT]
 SE ((ST1 = 0) E (ST2 = 0)) E (STG = 0) ENTAO
 EXT <- EXT + EXT1
 SENAO
 EXT <- EXT + " E " + EXT1
 FIMSE
 ST3 <- 1
 INTERROMPA
 FIMSE
 CT <- CT + 1
 SE (CT = 20) ENTAO
 INTERROMPA
 FIMSE
 FIMENQUANTO
 CT <- 1
 ENQUANTO (CARACPNUM(COPIA(VA,2,1)) = 0) OU (CARACPNUM(COPIA(VA,2,1)) <> 1) FACA
 SE (CARACPNUM(COPIA(VA,3,1)) = CT) ENTAO
 EXT1 <- B[CT]
 SE ((ST1 = 0) E (ST2 = 0)) E (STG = 0) ENTAO
 EXT <- EXT + EXT1
 SENAO
 EXT <- EXT + " E " + EXT1
 FIMSE
 ST3 <- 1
 INTERROMPA
 FIMSE
 CT <- CT + 1
 SE (CT = 10) ENTAO
 INTERROMPA
 FIMSE
 FIMENQUANTO
 SE ((( (ST1 = 1) OU (ST2 = 1)) OU (ST3 = 1) ) OU ((P = 3) E (INT(CARACPNUM(VALOR)) <> 0)) ) ENTAO
 SE (P = 1) ENTAO
 SE (CARACPNUM(V[1]) <> 0) E (CARACPNUM(V[2]) = 0) E (CARACPNUM(V[3]) = 0) ENTAO
 SE (CARACPNUM(VA) = 1) ENTAO
 EXT <- EXT + " MILHAO DE"
 SENAO
 EXT <- EXT + " MILHOES DE"
 FIMSE
 SENAO
 SE (CARACPNUM(V[1]) <> 0) E ((CARACPNUM(V[2]) <> 0) OU (CARACPNUM(V[3]) <> 0)) ENTAO
 SE (CARACPNUM(VA) = 1) ENTAO
 EXT <- EXT + " MILHAO"
 SENAO
 EXT <- EXT + " MILHOES"
 FIMSE
 FIMSE
 FIMSE
 FIMSE
 SE (P = 2) ENTAO
 EXT <- EXT + " MIL"
 FIMSE
 SE (P = 3) ENTAO
 SE (INT(CARACPNUM(VALOR)) = 1) ENTAO
 EXT <- EXT + " " + LTRIM(MOEDAS[1]) // REAL
 SENAO
 EXT <- EXT + " " + LTRIM(MOEDAS[2]) // REAIS
 FIMSE
 FIMSE
 SE (P = 4) ENTAO
 SE (CARACPNUM(VA) = 1) ENTAO
EXT <- EXT + " " + LTRIM(MOEDAS[3]) // CENTAVO
 SENAO
 EXT <- EXT + " " + LTRIM(MOEDAS[4]) // CENTAVOS
 FIMSE
 FIMSE
 STG <- 1
 FIMSE
 FIMPARA
 EXT <- MAIUSC(EXT)
 //* ----- Verifica se a unidade inicial comeca c/ ou s/ o H. (MIL) -----
 SE (INT(CARACPNUM(VALOR)) > 999) ENTAO
 E100 <- POS("UM", EXT)
 SE ((E100 > 0) E (POS("MIL", EXT)>0)) ENTAO
 EXT <- "H" + LTRIM(EXT)
 FIMSE
 FIMSE
 E100<- POS("HUM",EXT)
 SE ((E100 <> 0) E (POS("CENT",EXT)<> 0)) ENTAO
 EXT <- Copia( EXT, E100+1,Compr(EXT))
 FIMSE
 SENAO
 SE (Int(QVALOR) = 0) ENTAO
 EXT <- "Zero"
 FIMSE
 SE ( QVALOR < 0) ENTAO
 EXT <- "Valor Negativo"
 FIMSE
 SE ( QVALOR > 999999999.99) ENTAO
 EXT <- "Valor muito alto"
 FIMSE
 FIMSE
 //*---------------------------------------------------------------------
 TEXTO <- LTRIM(EXT)
 RETORNE TEXTO
FimFuncao
//===========================================================================
//Programa principal
Inicio
 ValorExt <- ""
 LimpaTela
 Escreva("Digite qualquer Valor [até 999999999.99]: ")
 Leia(ValorNum)
 ValorExt <- ValorPorExtenso(ValorNum)
 Escreval("")
 Escreval(ValorExt)
 Escreval
FimAlgoritmo
VISUALG3/help/tela_nenhum2.png
VISUALG3/Exemplos/Caracol2.ALG
Algoritmo "Caracol"
// Disciplina: [Linguagem e Lógica de programaçao] 
// Professor: Antonio Carlos Nicolodi
// Função: Calcula os passos de um caracol para subir o poço
// Autor : Antonio Carlos Nicolodi
// Data : 05/04/2015 
Var 
 Sobe, Desce: Real 
 Dias, Total : Inteiro
 
Inicio
 Sobe <- 0.0
 Desce <- 0.5
 Dias <- 0
 Total <- 10
 Limpatela		
 Escreval("Um dia um caracol estava andando e caio em um poço")
 Escreval("Cálcular o tempo que ele levaria pra sair desse poço")
 Escreval("========================================================")
 Escreval(" ")
 Para Dias de 0 ate Total faca
 se Sobe <= Total entao
 Sobe <- Sobe + 2 - Desce
 Escreval("Subiu 2 mts p/dia e baixou ",Desce," mts a noite, ficando ",Sobe," mts")
 senao
 interrompa
 fimse
 fimpara
 Escreval(" ")
 Escreval("O Caracol levou ",Dias," dias")
 Escreval(" ")
 
fimAlgoritmo
VISUALG3/visualg3.tmp
/*********************************
Autor: Fernando Krein Pinheiro
Data: 06/04/2011
Linguagem: C
========= IMPORTANTE ===========
O código esta livre para usar,
citar e compartilhar desde que
mantida sua fonte e seu autor.
Obrigado.
*********************************
 Esse algoritmo é apenas uma
 simulação do que um algoritmo
 de eleição em anel faz nos
 sistemas distribuidos.
********************************/
#include <stdlib.h>
#include <stdio.h>
#define TAM 5 /*aqui pode-se definir o numero de processos que se quer, precisa ser (>=2) */
struct Processos{
 int pid;
};
typedef struct Processos Processos;
int falha()
{
 int falha;
 srand(time(NULL));
 falha = rand() % TAM;
 return falha;
}
int promove_eleicao()
{
 int eleicao;
 eleicao = rand() % TAM;
 return eleicao;
}
int main()
{
 Processos proc[TAM];
 int proc_falha = 0;
 int proc_eleicao = 0;
 int proc_lider = 0;
 int vet_proc[TAM],i,cont;
 if(TAM<2)
 {
 system("clear");
 printf("\033[31mERRO 666 :\033[37mVoce precisa ter pelo menos 2 processos.\n");
 sleep(3);
 exit(0);
 }
 system("clear");
 for(; cont<TAM+TAM; cont++)
 {
 //inicializa os processo preenchendo a struct com numero do processo (PID)
 for(i=0; i<TAM; i++)
 {
 vet_proc[i] = proc[TAM].pid = i;
 }
 do
 {
 proc_falha = falha();
 proc_eleicao = promove_eleicao();
 }while(proc_eleicao == proc_falha);
 //inicializa o processo com falha colocando -1
 for(i=0; i<TAM; i++)
 {
 if(vet_proc[i] == proc_falha)
 vet_proc[i] = -1;
 }
 proc_lider = vet_proc[0];
 for(i=0; i<TAM; i++)//faz a escolha do novo lider
 {
 if(vet_proc[i] > proc_lider)
 proc_lider = vet_proc[i];
 }
 printf("|\033[32m PROC PID\033[37m |\n");//faz a impressão na tela
 for(i=0; i<TAM; i++)
 {
 printf("| [%d] [%d] |\n",vet_proc[i],proc[TAM].pid=i);
 }
 sleep(1);
 printf("\n\nProcesso de PID\033[31m [%d]\033[37m falhou.\n",proc_falha);
 sleep(2);
 printf("Processo de PID\033[33m [%d]\033[37m iniciou eleicao.\n",proc_eleicao);
 sleep(2);
 printf("\033[36mEscolhendo novo lider...\033[37m \n");
 sleep(3);
 printf("Processo de PID\033[33m [%d]\033[37m e o novo lider.\n",proc_lider);
 sleep(3);
 system("clear");
}
return 0;
}
VISUALG3/Exemplos/inssort.alg
algoritmo "sort_insercao"
// Disciplina: [Linguagem e Lógica de programaçao] 
// Função : Algoritmo de SORT por inserção
// Autor : Cláudio Morgado de Souza
// Data : 7/6/2003
// Seção de Declarações 
var
 v : vetor [1..20] de inteiro
 j,k,i,temp : inteiro
inicio
// Seção de Comandos
 aleatorio 1,100
 eco off
 para j de 1 ate 20 faca
 leia(v[j])
 fimpara
 para j de 1 ate 19 faca
 k <- j
 para i de (j+1) ate 20 faca
 se v[i] < v[k] entao
 k <- i
 fimse
 fimpara
 se k > j entao
 temp <- v[j]
 v[j] <- v[k]
 v[k] <- temp
 fimse
 fimpara
 para j de 1 ate 20 faca
 escreval(v[j])
 fimpara
fimalgoritmo
VISUALG3/Exemplos/interrompa.alg
Algoritmo "interrompa"
// Disciplina: [Linguagem e Lógica de programaçao] 
// Função : Demonstrar o uso dos comandos interrompa e fimrepita
// Autor :
// Data : 04/01/2004
// Seção de Declarações 
var x : inteiro
inicio
x <- 0
repita
 x <- x + 1
 escreva(x)
 se x = 10 entao
 interrompa // não estruturado, mas usado por alguns autores...
 fimse
fimrepita
escreval()
// O trecho acima é o mesmo que:
x <- 0
repita
 x <- x + 1
 escreva(x)
ate x = 10
fimalgoritmo
VISUALG3/help/Principal_arquivos/image008.jpg
VISUALG3/visualg30.exe
VISUALG3/Exemplos/CALENDARIO.ALG
Algoritmo "CALENDARIO"
// Disciplina: [Linguagem e Lógica de programaçao] 
// Professor: Antonio Carlos Nicolodi
// Função : Mostra um calendário a partir de uma data
// Autor : Antonio Carlos Nicolodi
// Data : 19/05/2015
var
// Seção de Declarações das variáveis 
 AM : vetor[1..6, 1..7] DE CARACTER // A matriz 6X7
 vt : vetor[0..6] de caracter // valor da tabela
dia,mes,ano : INTEIRO
 i,j,k,t,d : INTEIRO
linha,coluna: INTEIRO
 Ultimo : Inteiro
 a,y,m,q : REAL
aa,yy,mm,qq : REAL
 Flag : Logico
pd,sx,xm,xs : CARACTER
//
// Funçoes do programa
//
Funcao Data_ok(xm : Caracter) : Logico
Var
Bisext,Resp : Logico
dia,mes,ano : Inteiro
xBar1,xbar2 : Inteiro
Tamh,Ultimo : Inteiro
B1,B2,Barra : caracter
Inicio
// Valores iniciais das variáveis
 Resp:= Verdadeiro
 Tamh:= Compr(xm)
 Barra:= "/"
 Bisext:= Falso
 Se Tamh = 10 Entao
 Dia := CaracpNum(copia(xm,1,2))
 B1 := copia(xm,3,1)
 Mes := CaracpNum(copia(xm,4,2))
 B2 := copia(xm,6,1)
 Ano := CaracpNum(copia(xm,7,4))
 Senao
 Resp:= Falso
 Fimse
// Compara se o ano está (foi) digitado corretamente
 Se Resp Entao
 xBar1 := Pos(B1,Barra)//volta 0 se não achar 1ª Barra
 xBar2 := Pos(B2,Barra)//volta 0 se não
achar 2ª Barra
 Se ((xBar1 > 0) e (xBar2 > 0)) entao // verifica
 Resp := Verdadeiro
 Senao
 Resp := Falso
 Fimse
 SE ((Ano < 1900) ou (Ano>2350)) Entao
 Resp := Falso
 Senao
 Bisext := ((Ano mod 4) = 0)
 FimSe
 SE ((Mes < 1) ou (Mes>12)) Entao
 Resp := Falso
 FimSe
// Compara se o mes está (foi) digitado corretamente
 Ultimo := 31
 SE (Mes = 2) Entao
 Ultimo := 28
 Se Bisext Entao
 Ultimo := Ultimo + 1 // Ou seja 29
 Fimse
 Fimse
// Compara se o dia está (foi) digitado corretamente
 SE ((Dia < 1) ou (Dia> Ultimo)) Entao
 Resp := Falso
 FimSe
 Fimse
// Retorna Verdadeiro ou Falso
 Retorne Resp
Fimfuncao
Funcao StrZero(Numero,Qtde: Inteiro) : Caracter
Var
 Resp : Caracter
 i : inteiro
Inicio
// Preenche a resposta com Quantidade - 1 zeros a esquerda
 Para i de 1 ate Qtde-1 faca
 Resp := "0" + Resp
 Fimpara
 SE Numero < 10 entao
// Se o numero for menor que 10 coloca um zero na frente.
 Resp := Resp + NumpCarac(Numero)
 SENAO
// Transforma em caracter
 Resp := NumpCarac(Numero)
 FIMSE
// Retorna a resposta 01,02,03...09,10,11,12..31
 Retorne Resp
Fimfuncao
inicio
// Preenche a variável com os últimos dias de cada mes
 sx := "31,28,31,30,31,30,31,31,30,31,30,31"
// Preenche o vetor com os dias da semana
 vt[0] := "Dom"
 vt[1] := "Seg"
 vt[2] := "Ter"
 vt[3] := "Qua"
 vt[4] := "Qui"
 vt[5] := "Sex"
 vt[6] := "Sab"
// Entra em um laço (loop) pra pedir a data correta
 Flag := Verdadeiro
 Enquanto Flag Faca
 LimpaTela
 Escreva("Digite A DATA 99/99/9999 dia,mes,ano : ")
 Leia(xm)
 Se Nao(Data_ok(xm)) Entao
 Escreval("Data Invalida !!! - Tecle <ENTER>")
 Leia(xm)
 Flag := Verdadeiro
 senao
 Flag := Falso
 fimse
 FimEnquanto
//Desmonta a data em pedaços (dia, mês, ano) conf. a mascara
 Dia := CARACPNUM(COPIA(XM,1,2))
 Mes := CARACPNUM(COPIA(XM,4,2))
 Ano := CARACPNUM(COPIA(XM,7,4))
// Calcula o primeiro dia do mes para montar o calendário
 A := int((14 - Mes) / 12)
 Y := Ano - A
 M := Mes + (12 * A) - 2
// q := Dia+int((31*M)/12)+y+int(y/4)-int(y/100)+int(y/400)
 q := 01+int((31*M)/12)+y+int(y/4)-int(y/100)+int(y/400)
// mm:= int((31 * M)/12)
// qq:= int(y/4)
// aa:= int(y/100)
// yy:= int(y/400)
// q := Dia + mm + y + qq - aa + yy
// Observação PRA ACHAR O MOD (tem q ser inteiro)
// nessa fórmula vai retornar de 0-6
 d := Int(q) // Transroma o 'q' em inteiro = int(q)
 d := (d mod 7) //(resto da divisão por 7)
 xs := vt[d] // 'd' é real mas no vetor tem q ser
 // um valor inteiro
// Formula pra calcular a posição do ultimo dia/mês
 K := (Mes * 3) - 2
 Ultimo := CaracPNum(Copia(sx,K,2))
// Monta a matriz vazia
 para i de 1 ate 6 faca
 para j de 1 ate 7 faca
 am[i,j] := "__"
 fimpara
 fimpara
// Preenche a matriz com os dias
 T := 1
 Linha := 1
 Coluna := d + 1 //acrescenta de 1 (Um) p/ posicionar certo
 Enquanto T <= Ultimo faca
 Se T = 1 Entao
 Pd:= "1º"
 senao
 Pd:= StrZero(T,2)
 Fimse
 SE ((T > 1) e (T = DIA)) Entao
 Pd := "><"
 Fimse
 am[Linha,Coluna] := Pd // carrega o número do dia
 T := T + 1
 Coluna := Coluna + 1
 SE Coluna > 7 entao
 Coluna := 1
 Linha := Linha + 1
 SE Linha > 6 entao
 Linha := 1
 FIMSE
 FIMSE
 FIMENQUANTO
 LimpaTela
// Mostra o cabeçalho do calendário
 Escreval("Data: ",xm)
 Para i de 0 ate 6 faca
 Escreva(vt[i]," ")
 FimPara
// Mostrar o calendário na tela
 para i de 1 ate 6 faca
 Escreval(" ")
 para j de 1 ate 7 faca
 Escreva(" ",am[i,j]," ")
 fimpara
 fimpara
 Escreval(" ")
//
fimalgoritmo
VISUALG3/Exemplos/Serie2Converge.alg
Algoritmo "Serie2Converge"
//Mostra o número de termos da série 3/2^n para que seu valor seja 3
//Autor : Mário Leite
//E-mail : marleite@gmail.com
//-------------------------------------------------------------------
 Var n: inteiro
 S: real
 T: logico
Inicio
 LimpaTela
 T <- Verdadeiro
 n <- 1
 S <- 0
 Enquanto (T) Faca
 S <- S + 3/(2^n) //expressão da série
 {Formata a saída convenientemente}
 Se((n>=1) e (n<10)) Entao
 Escreval("Número de termos:",n, " ", "Valor da série:", S)
 Fimse
 Se((n>=10) e (n<100)) Entao
 Escreval("Número de termos:",n, " ", "Valor da série:", S)
 Fimse
 Se((n>=100) e (n<1000)) Entao
 Escreval("Número de termos:",n, " ", "Valor da série:", S)
 FimSe
 Se((n>=1000) e (n<10000)) Entao
 Escreval("Número de termos:",n, " ", "Valor da série:", S)
 FimSe
 Se((n>=10000) e (n<100000)) Entao
 Escreval("Número de termos:",n, " ", "Valor da série:", S)
 FimSe
 Se((n>=100000) e (n<1000000)) Entao
 Escreval("Número de termos:",n, " ", "Valor da série:", S)
 FimSe
 Se(n>=1000000) Entao
 Escreval("Número de termos:",n, " ", "Valor da série:", S)
 FimSe
 Se(S=3) Entao
 T <- Falso
 Interrompa
 Senao
 n <- n + 1
 FimSe
 FimEnquanto
 Escreval("")
 Escreval("Número de termos da série para que seu valor seja igual a 3:", n)
Fimalgoritmo
VISUALG3/help/barra2.jpg
VISUALG3/help.chm
VISUALG3/Exemplos/randomicos.alg.ALG
Algoritmo "semnome"
// Disciplina: [Linguagem e Lógica de programaçao] 
// Professor: Antonio Carlos Nicolodi
// Função: Calcula os passos de um caracol para subir o poço
// Autor : Antonio 
// Data : 21/06/2015
// Seção de Declarações 
var
 i : inteiro
 x : real
 matriz : vetor[1..11] de real
inicio
// Seção de Comandos 
i := 1
repita
 x := randi(10)
 matriz[i] := x
 i := i + 1
ate i >= 10
para i de 1 ate 10 faca
 escreval(matriz[i])
fimpara
fimalgoritmo
VISUALG3/help/Principal_arquivos/image013.jpg
VISUALG3/listas.txt
5
MESES
12
Janeiro
Fevereiro
Março
Abril
Maio
Junho
Julho
Agosto
Setembro
Outubro
Novembro
Dezembro
DIAS DA SEMANA
7
Segunda-feira
Terça-feira
Quarta-feira
Quinta-feira
Sexta-feira
Sábado
Domingo
ESTADOS
27
Acre
Alagoas
Amazonas
Amapá
Bahia
Ceará
Distrito Federal
Espírito Santo
Goiás
Maranhão
Mato Grosso
Mato Grosso do Sul
Minas Gerais
Pará
Paraíba
Paraná
Pernambuco
Piauí
Rio de Janeiro
Rondônia
Rio Grande do Norte
Roraima
Rio Grande do Sul
Santa Catarina
Sergipe
São Paulo
Tocantins
CIDADES DE SANTA CATARINA
293
Abdon Batista
Abelardo Luz
Agrolandia
Agronomica
Agua Doce
Aguas Frias
Aguas Mornas
Aguas de Chapeco
Alfredo Wagner
Alto Bela Vista
Anchieta
Angelina
Anita Garibaldi
Anitapolis
Antonio Carlos
Apiuna
Arabuta
Araquari
Ararangua
Armazem
Arroio Trinta
Arvoredo
Ascurra
Atalanta
Aurora
Balneario Arroio do Silva
Balneario Barra do Sul
Balneario Camboriu
Balneario Gaivota
Bandeirante
Barra Bonita
Barra Velha
Bela Vista do Toldo
Belmonte
Benedito Novo
Biguacu
Blumenau
Bocaina do Sul
Bom Jardim da Serra
Bom Jesus do Oeste
Bom Jesus
Bom Retiro
Bombinhas
Botuvera
Braco do Norte
Braco do Trombudo
Brunopolis
Brusque
Cacador
Caibi
Calmon
Camboriu
Campo Alegre
Campo Belo do Sul
Campo Ere
Campos Novos
Canelinha
Canoinhas
Capao Alto
Capinzal
Capivari de Baixo
Catanduvas
Caxambu do Sul
Celso Ramos
Cerro Negro
Chapadao do Lageado
Chapeco
Cocal do Sul
Concordia
Cordilheira Alta
Coronel Freitas
Coronel Martins
Correia
Pinto
Corupa
Criciuma
Cunha Pora
Cunhatai
Curitibanos
Descanso
Dionisio Cerqueira
Dona Emma
Doutor Pedrinho
Entre Rios
Ermo
Erval Velho
Faxinal dos Guedes
Flor do Sertao
Florianopolis
Formosa do Sul
Forquilhinha
Fraiburgo
Frei Rogerio
Galvao
Garopaba
Garuva
Gaspar
Governador Celso Ramos
Grao Para
Gravatal
Guabiruba
Guaraciaba
Guaramirim
Guaruja do Sul
Guatambu
Herval d'Oeste
Ibiam
Ibicare
Ibirama
Icara
Ilhota
Imarui
Imbituba
Imbuia
Indaial
Iomere
Ipira
Ipora do Oeste
Ipuacu
Ipumirim
Iraceminha
Irani
Irati
Irineopolis
Ita
Itaiopolis
Itajai
Itapema
Itapiranga
Itapoa
Ituporanga
Jabora
Jacinto Machado
Jaguaruna
Jaragua do Sul
Jardinopolis
Joacaba
Joinville
Jose Boiteux
Jupia
Lacerdopolis
Lages
Laguna
Lajeado Grande
Laurentino
Lauro Muller
Lebon Regis
Leoberto Leal
Lindoia do Sul
Lontras
Luiz Alves
Luzerna
Macieira
Mafra
Major Gercino
Major Vieira
Maracaja
Maravilha
Marema
Massaranduba
Matos Costa
Meleiro
Mirim Doce
Modelo
Mondai
Monte Carlo
Monte Castelo
Morro Grande
Morro da Fumaca
Navegantes
Nova Erechim
Nova Itaberaba
Nova Trento
Nova Veneza
Novo Horizonte
Orleans
Otacilio Costa
Ouro Verde
Ouro
Paial
Painel
Palhoca
Palma Sola
Palmeira
Palmitos
Papanduva
Paraiso
Passo de Torres
Passos Maia
Paulo Lopes
Pedras Grandes
Penha
Peritiba
Petrolandia
Picarras
Pinhalzinho
Pinheiro Preto
Piratuba
Planalto Alegre
Pomerode
Ponte Alta do Norte
Ponte Alta
Ponte Serrada
Porto Belo
Porto Uniao
Pouso Redondo
Praia Grande
Presidente Castelo Branco
Presidente Getulio
Presidente Nereu
Princesa
Quilombo
Rancho Queimado
Rio Fortuna
Rio Negrinho
Rio Rufino
Rio d'Oeste
Rio das Antas
Rio do Campo
Rio do Sul
Rio dos Cedros
Riqueza
Rodeio
Romelandia
Salete
Saltinho
Salto Veloso
Sangao
Santa Cecilia
Santa Helena
Santa Rosa de Lima
Santa Rosa do Sul
Santa Terezinha do Progresso
Santa Terezinha
Santiago do Sul
Santo Amaro da Imperatriz
Sao Bento do Sul
Sao Bernardino
Sao Bonifacio
Sao Carlos
Sao Cristovao do Sul
Sao Domingos
Sao Francisco do Sul
Sao Joao Batista
Sao Joao do Itaperiu
Sao Joao do Oeste
Sao Joao do Sul
Sao Joaquim
Sao Jose do Cedro
Sao Jose do Cerrito
Sao Jose
Sao Lourenco d'Oeste
Sao Ludgero
Sao Martinho
Sao Miguel d'Oeste
Sao Miguel da Boa Vista
Sao Pedro de Alcantara
Saudades
Schroeder
Seara
Serra Alta
Sideropolis
Sombrio
Sul Brasil
Taio
Tangara
Tigrinhos
Tijucas
Timbe do Sul
Timbo Grande
Timbo
Tres Barras
Treviso
Treze Tilias
Treze de Maio
Trombudo Central
Tubarao
Tunapolis
Turvo
Uniao do Oeste
Urubici
Urupema
Urussanga
Vargeao
Vargem Bonita
Vargem
Vidal Ramos
Videira
Vitor Meireles
Witmarsum
Xanxere
Xavantina
Xaxim
Zortea
TESTE
0
VISUALG3/help/Principal_arquivos/image012.png
VISUALG3/help/tela_agua1.PNG
VISUALG3/Exemplos/Nome_inverso.alg
Algoritmo "Invertenome"
// Disciplina: [Linguagem e Lógica de programaçao] 
// Professor: Antonio Carlos Nicolodi
// Função: Calcula os passos de um caracol para subir o poço
// Autor : Antonio Carlos Nicolodi
// Data : 05/04/2015 // Função :
// Autor :
// Data : 09/04/2015
// Seção de Declarações 
var
 s,c : caracter
 i,x : inteiro
inicio
// Seção de Comandos 
 Escreva("Digite um nome : ")
 Leia(s)
 x <- compr(s)
 c <- ""
 para i de x ate 1 passo -1 faca
 c <- c + copia(s,i,1)
 fimpara
 Escreva(" ")
 Escreval(c)
fimalgoritmo
VISUALG3/Exemplos/PI_EULER.ALG
Algoritmo "Pi_Euler"
//Calcula Pi usando 1.000.000 de termos na "Série de Euler"
//Autor : Mário Leite
//E-mail : marleite@gmail.com
//------------------------------------------------------------------------------
 var j: inteiro
 Soma, Pii: real
 Inicio
 Soma <- 0.0
 Cronometro on //liga o cronômetro
 Para j De 1 Ate 1000 Faca
 	Soma <- Soma + 1/(j^2)
 	Pii <- RaizQ(6*Soma)
 	Escreval(Pii) //valores parciais de Pi
 FimPara
 Cronometro off //desliga o cronômetro
 Escreval("")
FimAlgoritmo
VISUALG3/help/BARRA_STATUS_VISUALG3.PNG
VISUALG3/skins/Aluminio.asz
VISUALG3/help/Principal.htm
A
Tela Principal do VISUALG 3.0
			
 A tela do VISUALG compõe-se: Uma barra de menus, Uma barra de
 botões, uma área dos programas (ou área de edição e criação do código-fonte)
 e apresenta o nome dos algoritmos (arquivos). Uma área de variáveis de memória
 (globais e locais) dos programas, funções, procedimentos, que estão sendo
 executados no momento. Uma área de programas que mostra o resultado após a
 execução do código. E por último uma área ou TELA
 que mostra a execução do algoritmo, com o título: “CONSOLE SIMULANDO O MODO TEXTO DO MS-DOS”.
 No final contém uma barra de status contendo informações do programa e do
 algoritmo que está sendo editado e executado.
  
 O editor de textos (que na versão
 anterior ocupara a metade superior da tela), agora ocupa metade da esquerda
 da tela e deverá conter o código-fonte do algoritmo em Portugol. Antes dos programas
 serem carregados, na área do editor há um "esqueleto" de
 pseudocódigo, com comentários e informações iniciais com a
 intenção de poupar trabalho ao usuário e de mostrar o formato básico que deve
 ser seguido. Mostrando a interface do VISUALG.
 Da esquerda mostrando a nova roupagem com seu novo layout (leiaute) e na
 direita mostra como era a versão 2 e a versão 2.5, já desativada.
 
 
			
 
 			
 
 
A Barra
de Tarefas
Contém a barra do MENU PRINCIPAL  no VISUALG 3.0, com as opções { Arquivo, Editar,
Run (executar o algoritmo), Exportar, Manutenção, Help
(Ajuda) }. 
Depois
abaixo tem uma Barra de botões com os atalhos das opções do menu (novo, abrir,
gravar, rodar, passo, time, parar, etc.), alguns botões das versões antigas
foram substituídos.
			
 Abrir [Ctrl-A]:       Abre um arquivo anteriormente gravado,
 substituindo o texto presente no editor. Se este tiver sido modificado, o
 VisuAlg pedirá sua confirmação para salvá-lo antes que seja sobreposto.
 Novo [Ctrl-N]:      Cria um novo
 "esqueleto" de pseudocódigo, substituindo o texto presente no
 editor. Se este tiver sido modificado, o VisuAlg pedirá sua confirmação para
 salvá-lo antes que seja sobreposto.
 Salvar [Ctrl-S]:     Grava
 imediatamente o texto presente no editor. Na primeira vez que um novo texto é
 gravado, o VisuAlg pede seu nome e localização.
 Imprimir:             Imprime
 imediatamente na impressora padrão o texto presente no editor. Para
 configurar a impressão, use o comando Imprimir do menu Arquivo (acessível
 também pelo atalho Ctrl-P).
 Cortar [Ctrl-X]:     Apaga texto
 selecionado, armazenando-o em uma área de transferência.
 Copiar [Ctrl-C]:    Copia o texto
 selecionado para a área de transferência.
 Colar [Ctrl-V]:      Copia texto da
 área de transferência para o local em que está o cursor.
 Gravar bloco de texto: Permite a gravação em arquivo de um texto
 selecionado no editor. A extensão sugerida para o nome do arquivo é .inc.
 Inserir bloco de texto: Permite a inserção do conteúdo de um arquivo. A
 extensão sugerida para o nome do arquivo é .inc.
 Desfazer [Ctrl-Z]:  Desfaz último
 comando efetuado.
 Refazer [Shift-Ctrl-Z]: Refaz último comando desfeito.
 Localizar [Ctrl-L]:  Localiza no
 texto presente no editor determinada palavra especificada.
 Substituir [Ctrl-U]:  Localiza no
 texto presente no editor determinada palavra especificada, substituindo-a por
 outra.
 Corrigir Indentação [Ctrl-G]: Corrige automaticamente a indentação
 (ou tabulação) do pseudocódigo, tabulando cada comando interno com espaços à
 esquerda.
 Numerar linhas: Ativa ou desativa a exibição dos números das linhas
na
 área à esquerda do editor. A linha e a coluna do editor em que o cursor está
 em um determinado momento também são mostradas na barra de status
 (parte inferior da tela). Por motivos técnicos, esta opção é automaticamente
 desativada durante a execução do pseudocódigo, mas volta a ser ativada logo
 em seguida.
 Mostrar variáveis modificadas: Ativa ou desativa a exibição da
 variável que está sendo modificada. Como o número de variáveis pode ser
 grande, muitas podem estar fora da janela de visualização; quando esta
 característica está ativada, o VisuAlg rola a grade de exibição de modo que
 cada variável fique visível no momento em está sendo modificada. Este recurso
 é especialmente útil quando se executa um pseudocódigo passo a passo. Por
 questões de desempenho, a configuração padrão desta característica é desativada,
 quando o pseudocódigo está sendo executado automaticamente. No entanto, basta
 clicar este botão para executá-lo automaticamente com a exibição ativada. No
 final da execução, a configuração volta a ser desativada.
 
 
 
			
 Run
 (Executar)  ou [F9]:  Inicia (ou
 continua) a execução automática do pseudocódigo.
 Executar com timer [Shift-F9]:: Insere um atraso (que pode ser
 especificado no intervalo ao lado) antes da execução de cada linha. Também
 realça em fundo azul o comando que está sendo executado, da mesma forma que
 na execução passo a passo.
 Intervalo do timer: Atraso em cada linha, para quando se
 deseja executar o pseudocódigo com timer.
 Passo [F8]: Inicia (ou continua) a execução linha por linha do
 pseudocódigo, dando ao usuário a oportunidade de acompanhar o fluxo de
 execução, os valores das variáveis e a pilha de ativação dos subprogramas.
 Parar [Ctrl-F2]: Termina imediatamente a execução do pseudocódigo.
 Evidentemente, este botão fica desabilitado quando o pseudocódigo não está
 sendo executado.
 Liga/desliga breakpoint [F5]: Insere/remove um ponto de parada
 na linha em que esteja o cursor. Estes pontos de parada são úteis para a
 depuração e acompanhamento da execução dos pseudocódigos, pois permitem a
 verificação dos valores das variáveis e da pilha de ativação de subprogramas.
 
 Desmarcar todos os breakpoints [Ctrl-F5]:  Desativa todos os breakpoints que estejam ativados naquele momento. 
 Gerar valores aleatórios:  Ativa a
 geração de valores aleatórios que substituem a digitação de dados. A faixa
 padrão de valores gerados é de 0 a 100 inclusive, mas pode
 ser modificada (basta alterar intervalo ao lado). Para a geração de dados do
 tipo caractere, não há uma faixa pré-estabelecida: os dados gerados serão
 sempre strings de 5 letras maiúsculas.
 Intervalo dos valores aleatórios: Faixa de valores que serão gerados
 automaticamente, quando esta opção estiver ativada.
 Perfil [F7]:   Após a execução
 de um pseudocódigo, exibe o número de vezes que cada umas das suas linhas foi
 executada. É útil para a análise de eficiência (por exemplo, nos métodos de
 ordenação).
 Mostrar pilha de ativação [Ctrl-F3]: 
 Exibe a pilha de subprogramas ativados num dado momento. Convém
 utilizar este comando em conjunto com breakpoints ou com a execução
 passo a passo.
 Ajuda [F1]:  Possibilita acesso às
 páginas de ajuda e às informações sobre o VISUALG.
 
 
			
 Quadro de Variáveis              
 			
 É
 formado por uma grade na qual são mostrados o escopo de cada variável (se for
 do programa principal, será global; se for local, será apresentado o nome do
 subprograma onde foi declarada), seus nomes (também com os índices, nos casos
 em que sejam vetores), seu tipo: ("I" para inteiro, "R"
 para real, "C" para caractere e "L" para lógico) e o seu
 valor corrente. 
 A
 versão atual do VISUALG permite a visualização de até 500 variáveis (contando
 individualmente cada elemento dos vetores).
  
 
A Barra de Status
			
 
 			
 Situada na parte
 inferior da tela, esta barra contém: 4 partes, onde na primeira parte é
 apresentada o nº da Linha : Coluna. Ex. 9:3. 
 Na segunda parte
 dois situação atual com as palavras Modificado,
 Executando, Pesquisando, Substituindo ou em Branco. 
 
  
 No caso do
 pseudo-código seja alterado desde que foi carregado ou salvo pela última vez.
 
 Nesta barra, há ainda
 uma terceira parte que mostra um texto dizendo que: pode-se usar a sequência
 de teclas Ctrl e J que
 mostrará todos os comandos, funções e operadores e as setas para
 movimentar-se no texto. 
 A quarta parte,
 mostram as mensagens sensitivas que definem cada posição do programa,
 identificando-as.
 
  Objetivos   
Tela principal   
Menu   
A linguagem do
VisuAlg    Referências da linguagem do VisuAlg   Mais recursos
 
VISUALG3/Exemplos/REGISTROS.ALG
Algoritmo "Registros"
// Disciplina : [Linguagem e Lógica de programaçao]
// Professor(a): Antonio Carlos Nicolodi
// Descrição : Menu com ordenação de registros
// Autor(a) : Nome do(a) aluno(a)
// Data atual : 07/09/2015
tipo
 tdados = registro
 codigo: inteiro
 nome: caractere
 fimregistro
Var
 dados : vetor[1..2] de tdados
 Max_itens : Inteiro
 opcao : Caracter // Opção de escolha
 X,FLAG: LOGICO // variáveis de controle
 //
procedimento leituradosdados
var i: inteiro
inicio
 //Caso você mesmo queira digitar os valores, comente as linhas
 // aleatorio on e aleatorio off abaixo
 aleatorio on
 para i de 1 ate MAX_ITENS faca
 escreva("Digite o codigo do ",i,"o registro:")
 leia(dados[i].codigo)
 escreva("Digite o nome do ",i,"o registro:")
 leia(dados[i].nome)
 fimpara
 aleatorio off
fimprocedimento
procedimento ordenapornome
var a,b: inteiro
 temp: tdados
inicio
 // Ordenação
 para a de 1 ate MAX_ITENS faca
 para b de 1 ate MAX_ITENS-1 faca
 se dados[b].nome > dados[b+1].nome entao
 // Atribuicao do registro inteiro
 temp <- dados[b]
 dados[b] <- dados[b+1]
 dados[b+1] <- temp
 fimse
 fimpara
 fimpara
fimprocedimento
procedimento ordenaporcodigo
var a,b: inteiro
 temp: tdados
inicio
 // Ordenação
 para a de 1 ate MAX_ITENS faca
 para b de 1 ate MAX_ITENS-1 faca
 se dados[b].codigo > dados[b+1].codigo entao
 // Atribuicao do registro campo a campo
 temp.codigo <- dados[b].codigo
 temp.nome <- dados[b].nome
 dados[b] <- dados[b+1]
 dados[b+1] <- temp
 fimse
 fimpara
 fimpara
fimprocedimento
procedimento imprime
var a: inteiro
inicio
 // Impressão dos dados ordenados
 escreval("Item - Codigo Nome")
 para a de 1 ate MAX_ITENS faca
 escreval(a:4," - ", dados[a].codigo : 6, " ", dados[a].nome)
 fimpara
fimprocedimento
Procedimento Inclusao
Inicio
 Escreval("Inclusão")
 leituradosdados()
 Escreva("tecle <enter>")
 LEIA(X)
FimProcedimento
Procedimento Consulta
Inicio
 Escreval("Consulta")
 imprime()
 Escreva("tecle <enter>")
 LEIA(X)
FimProcedimento
Procedimento Ordenar_N
Inicio
 Escreval("Ordenar por nome")
 ordenapornome()
 imprime()
 Escreva("tecle <enter>")
 LEIA(X)
FimProcedimento
Procedimento Ordenar_C
Inicio
 Escreval("Ordenar por código")
 ordenaporcodigo()
 imprime()
 Escreva("tecle <enter>")
 LEIA(X)
FimProcedimento
// Aqui inicia o programa
inicio
 Max_itens := 2
 X := VERDADEIRO
 FLAG <- X
 ENQUANTO FLAG FAÇA
 X := VERDADEIRO
 MUDACOR("Amarelo","FRENTE")
 limpatela
 Escreval("*** Menu ***")
 Escreval("1 - Inclusão")
 Escreval("2 - Consulta")