ARRAYS

Na coluna deste mês veremos uma coletânea de algumas tarefas úteis para arrays. A fonte das mesmas é o ótimo site ActionScript.org e procurei fazer adaptações e detalhei a lógica e o funcionamento dos scripts de maneira que ficassem mais claros. Espero que as explicações ajudem.

- Multiplicar elementos de uma matriz

1. Crie um novo documento Flash.
2. Nomeie a layer como AS.

3. Tecle F9 no frame 1 desta layer e insira o seguinte código:

//INÍCIO DO CÓDIGO

//Função para classificar a matriz enviada
function classificar(matriz) {
//Cria a variável tmp, que é uma matriz
var tmp = new Array();
//Atribui ao primeiro elemento desta matriz o 1 (neste exemplo)
tmp[0] = matriz[0];
//Começa o loop que varia de 1 até 8 (neste exemplo), com incremento de 1
for (var i = 1; i<matriz.length; i++) {
//Quando o Flash “passa” pela primeira vez aqui, atribui o valor 25 ao
//à variável num; na segunda vez, o valor 101 e assim por diante
num = matriz[i];
//Define a variável “feito” com o conteúdo booleano false
var feito = false;
//Loop que varia de 0 até o comprimento da matriz t no momento, com
//incremento de 1
for (var j = 0; j<tmp.length; j++) {
//Avalia primeiro se as duas condições iniciais são verdadeiras
//(num>tmp[j]) e (num<tmp[j+1]) ou se a condição (num == tmp[j])
//é verdadeira, em caso positivo…
if (((num>tmp[j]) && (num<tmp[j+1])) || (num == tmp[j])) {
//Inclui na matriz tmp, no índice “j+1″, informando que nenhum
//elemento será apagado e que o valor de num será inserido na
//posição indicada aqui pelo primeiro parâmetro
tmp.splice(j+1, 0, num);
//Atribui o valor booleano true para a variável “feito”
feito = true;
//Encerra o for
break;
}
//Se as condições do if não resultarem um valor true, então a
//o valor de j é incrementado de 1 unidade e o loop for continua
}
if ((!feito) && (num<tmp[0])) {
//Se (feito = false) e num<tmp[0], então inclui o valor de num
//no início da matriz tmp, retornando o novo comprimento da matriz
tmp.unshift(num);
}
else if ((!feito) && (num>tmp[tmp.length-1])) {
//Caso as condições (!feito) && (num<tmp[0]) anteriores não
//resultem num valor verdadeiro, este outro if é analisado;
//Se (!feito) && (num>tmp[tmp.length-1]) gerar um valor verdadeiro,
//então o valor de num é incluído no final da matriz tmp e retorna
//o tamanho da matriz.
tmp.push(num);
}
}
//A função classificar retorna o conteúdo da matriz tmp, ou seja,
//a matriz já classificada
return tmp;
}
//A matriz temp é definida como uma matriz de 8 elementos
temp = new Array(1, 25, 101, 23, 52, 52, 92, 4);
//A função classificar é chamada enviando a matriz temp como parâmetro e o
//resultado é armazenado na variável temp
temp = classificar(temp);
//O conteúdo da variável temp é enviado ao painel de saída
trace(temp);
//FIM DO CÓDIGO

- Contar as repetições de um elemento dentro da matriz

1. Siga os passos 1 a 3 do exemplo “Multiplicar elementos de uma matriz” substituindo o código pelo que segue:

//INÍCIO DO CÓDIGO
// Função para verificar se um valor está contido numa matriz
// A função ContarOcorrencias é definida para receber um parâmetro chamado valor
Array.prototype.ContarOcorrencias = function(valor) {
//Atribuímos 0 à variável que armazenará quantidade de ocorrências do valor procurado
var encontradas = 0;
// Começa o loop que se repetirá o número de vezes correspondente ao tamanho da matriz
for (i=0; i<this.length; i++) {
// Se o valor corresponder ao valor procurado adicionar 1 ao contador
if (this[i] == valor) {
encontradas++;
}
}
// Retorna o total de ocorrências encontradas
return encontradas;
};
//EXEMPLO
// Declara as variáveis a (matriz de elementos) e contador (para armazenar a quantidade de ocorrências)
var contador;
// Define a variável a como uma matriz e atribui os elementos à ela
a = new Array(1, 2, 3, 3, 3, 3, 3, 4);
// Chama a função ContarOcorrencias, passando como parâmetro o 3, armazenando o retorno da função na variável contador
contador = a.ContarOcorrencias(3);
// Envia para o painel de saída a quantidade de ocorrências encontrada
trace(contador + ” ocorrências”);
//FIM DO CÓDIGO

- Criar alguns números sem repetição (configurável máx, mín e qtd)

1. Siga os passos 1 a 3 do exemplo “Multiplicar elementos de uma matriz” substituindo o código pelo que segue:

//INÍCIO DO CÓDIGO
//Função que sorteia os números sem repetí-los. Recebe como parâmetros o limite
//inferior, superior e a quantidade de números a serem sorteados dentro desta
//faixa
function sortearSemRepetir(valMin, valMax, qtdNumeros) {
//O total de números a serem sorteados menos 1 será o tamanho da
//matriz numeros retornados, que é definida na linha a seguir
numerosRetornados = new Array(qtdNumeros-1);
//O loop será repetido, neste exemplo, 6 vezes
//Observe que o c varia de 0 até 5, com incremento de 1
for (c=0; c<=qtdNumeros-1; c++) {
//É calculada a diferença entre o valor máximo e o valor mínimo
//e somado 1 ao resultado. Este é multiplicado por um número n
//aleatório escolhido pelo Flash, tal que 0 <= n < 1. Este
//resultado é arredondado para o inteiro mais próximo e então
//é somado ao valor mínimo. Feito isso, é então atribuído ao
//elemento da matriz numerosRetornados
numerosRetornados = valMin+Math.floor(Math.random()*(valMax+1-valMin));
//As instruções do “sub-loop” for serão repetidas até que x
//seja menor ou igual a c-1. O x é incrementado de 1 a cada
//passagem
for (x=0; x<=c-1; x++) {
//Se o valor de numerosRetornados for igual ao valor
//de numerosRetornados[x]…
if (numerosRetornados == numerosRetornados[x]) {
//…então o valor nulo é atribuído ao elemento
//da matriz numerosRetornados
numerosRetornados = “”;
//O valor de c é diminuído de 1 unidade
–c;
}
}
}
//A função retorna o conteúdo da matriz numerosRetornados como
//resultado
return numerosRetornados;
}
//É chamada a função sortearSemRepetir passando como valores mínimo, máximo e
//quantidade de números o 0, 5 e 6 respectivamente.
//Após retornado o resultado, o mesmo é impresso no painel de saída
trace(sortearSemRepetir(0, 5, 6));
//FIM DO CÓDIGO

- Embaralhador de matriz

1. Siga os passos 1 a 3 do exemplo “Multiplicar elementos de uma matriz” substituindo o código pelo que segue:

//INÍCIO DO CÓDIGO
//Função que embaralha a matriz
Array.prototype.embaralharMatriz = function() {
//O resultado da function que processa os valores a e b são classificados
this.sort(function (a, b) {
trace(“a = “+a);
trace(“b = “+b);
trace(“i = “+i);
trace(“”);
//Um número maior ou igual a zero e menor do que 1 é escolhido
//aleatoriamente, multiplicado por 100, subtraído 50 de seu valor,
//arredondado para o inteiro mais próximo e atribuído à variável i
i = Math.round((Math.random()*100)-50);
//O valor i é retornado
return i;
});
//O valor da matriz
return this;
};
//A variável n é definida como uma matriz com 10 elementos declarados a seguir
var n = new Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
//O conteúdo da matriz n é impresso no painel de saída para que possamos
//compará-lo com os resultados produzidos pela função embaralharMatriz
trace(n);
//Chamamos diversas vezes a função embaralharMatriz para a matriz n para que
//você note que os resultados são realmente aleatórios
n.embaralharMatriz();
trace(n);
n.embaralharMatriz();
trace(n);
n.embaralharMatriz();
trace(n);
stop();
//FIM DO CÓDIGO

- Embaralhador de matriz II

1. Siga os passos 1 a 3 do exemplo “Multiplicar elementos de uma matriz” substituindo o código pelo que segue:

//INÍCIO DO CÓDIGO
//As matrizes são definidas
matrizOriginal = ["Kasparov", "Karpov", "Anand", "Topalov", "Leko"];
matrizTemporaria = new Array();
novaMatriz = new Array();
//Inicia-se o loop que vai de 0 até 4, neste exemplo, tendo a incrementado a
//cada passagem em 1 unidade
for (a=0; a<matrizOriginal.length; a++) {
//O valor atual de a é inserido no final da matrizTemporaria
matrizTemporaria.push(a);
}
//Começa o loop que vai de 0 até 4, neste exemplo, tendo a incrementado a cada
//passagem em 1 unidade
for (a=0; a<matrizOriginal.length; a++) {
//Estes comandos são executados ao menos uma vez (do/while)
do {
//À variável aux é atribuído um valor aleatório baseado no tamanho da
//matrizTemporaria
aux= random(matrizTemporaria.length);
//O valor do elemento da matrizTemporaria obtido através da atribuição
//anterior é configurado para a variável novoLocal
novoLocal = matrizTemporaria[aux];
//Estes comandos serão repetidos enquanto matrizOriginal[a] for igual à
//matrizOriginal[novoLocal] e “a” for diferente de 4, neste caso.
} while (matrizOriginal[a] == matrizOriginal[novoLocal] && a != matrizOriginal.length-1);
//Apaga o elemento de índice aux
matrizTemporaria.splice(aux, 1);
//Se matrizOriginal[a] é diferente de matrizOriginal[novoLocal]
if (matrizOriginal[a] != matrizOriginal[novoLocal]) {
//Inclui o conteúdo de matrizOriginal[novoLocal] no final da novaMatriz
novaMatriz.push(matrizOriginal[novoLocal]);
}
//Caso contrário…
else {
//Inclui o conteúdo da matrizOriginal[novoLocal] no início da
//novaMatriz
novaMatriz.unshift(matrizOriginal[novoLocal]);
}
}
//Converte os conteúdos de matrizOriginal e novaMatirz para String para que
//possam ser impressos no painel de saída
trace(matrizOriginal.toString());
trace(novaMatriz.toString());
//FIM DO CÓDIGO

- Encontrar próximo elemento e anterior dentro de uma matriz

1. Siga os passos 1 a 3 do exemplo “Multiplicar elementos de uma matriz” substituindo o código pelo que segue:

//INÍCIO DO CÓDIGO
// Definição da função avancar que recebe um parâmetro chamado valorAtual (o valor sobre o qual descobrirá qual é o seu posterior);
Array.prototype.avancar = function(valorAtual) {
// Definição da variável auxiliar, que armazenará o índice do elemento posterior ao enviado como parâmetro;
var auxiliar;
// Não deixe de ler os comentários sobre o for…in no Help para entender melhor este loop. Início do loop sobre todas as propriedades da matriz
// minhaMatriz. As propriedades serão armazenadas na variável indexadora at. Se você tirar o // que coloquei no código terá essa saída (aqui mostrada
// parcialmente):
//
// at: voltar
// auxiliar: undefined
//
// at: avancar
// auxiliar: voltar
//
// at: 13
// auxiliar: avancar
//
// at: 11
// auxiliar: 13
//
// at: zz
// auxiliar: 11
//
// at: 25
// auxiliar: zz
//
// at: 7
// auxiliar: 25
//
// at: kk
// auxiliar: 7
//
// at: 3
// auxiliar: kk
//
// at: 1
// auxiliar: 3
//
// Observe que quando o Flash encontra o valor desejado interrompe o for…in.
for (at in this) {
//trace (“at: “+at);
//trace (“auxiliar: “+auxiliar);
//trace(” “);
// Compara se o valor passado através do parâmetro valorAtual é exatamente igual ao item da matriz analisado neste momento do loop for…in. Caso
// seja verdadeira a expressão, executará a linha do return, caso contrário continua a execução onde se atribui o valor de at para a variável auxiliar;
if (valorAtual == this[at]) {
// Retorna como valor da função o item da matriz cujo índice está armazenado na variável auxiliar e interrompe a execução da função avancar;
return this[auxiliar];
}
// Enquanto o valor procurado não for encontrado ou o final da matriz não chegar, esta linha será executada. Nela o Flash atribui o valor de at à variável
// auxiliar;
auxiliar = at;
}
};
// Definição da função voltar que recebe um parâmetro chamado valorAtual (o valor sobre o qual descobrirá qual é o seu anterior);
Array.prototype.voltar = function(valorAtual) {
// São definidas as variáveis auxiliar e i, sendo que a segunda recebe o valor 0. A variável auxiliar armazenará o índice do elemento anterior ao enviado
// como parâmetro enquanto a i será usada como incrementador;
var auxiliar;
var i = 0;
/* Não deixe de ler os comentários sobre o for…in no Help para entender melhor este loop. Início do loop sobre todas as propriedades da matriz minhaMatriz. As propriedades serão armazenadas na variável indexadora at. Se você tirar o // que coloquei no código terá essa saída (aqui mostrada parcialmente):
at: voltar
auxiliar: undefined

at: avancar
auxiliar: undefined

at: 13
auxiliar: undefined

at: 11
auxiliar: undefined

at: zz
auxiliar: 4
Observe que quando o Flash encontra o valor desejado interrompe o for…in. */
for (at in this) {
//trace (“at: “+at);
//trace (“auxiliar: “+auxiliar);
//trace(” “);
/* Se o conteúdo da variável auxiliar for exatamente igual ao valor do i executará o return this[at];, caso contrário vai para a linha do comando if (valorAtual == this[at]) {.*/
if (auxiliar == i) {
// Encerra a função retornando como valor o conteúdo da matriz de índice armazenado na variável at;
return this[at];
}
/* Se o valorAtual (o que procuramos) for exatamente igual ao item da matriz que é analisado neste momento executará a linha auxiliar = (i+1); caso contrário, executará a linha i++;*/
if (valorAtual == this[at]) {
// Atribui à variável auxiliar o valor do próximo índice;
auxiliar = (i+1);
}
// Incrementa em 1 unidade o valor de i;
i++;
}
};
//Definição da matriz minhaMatriz e de seus elementos;
minhaMatriz = new Array();
minhaMatriz[1] = “Primeiro valor”;
minhaMatriz[3] = “Terceiro valor”;
minhaMatriz['kk'] = “Valor qualquer”;
minhaMatriz[7] = “Sétimo Item”;
minhaMatriz[25] = “Vigésimo quinto valor”;
minhaMatriz['zz'] = “Outro valor qualquer”;
minhaMatriz[11] = “Décimo primeiro valor”;
minhaMatriz[13] = “Décimo terceiro valor”;
// O trace imprime no painel de saída os valores procurados.
trace(“Item seguinte: “+minhaMatriz.avancar(“Primeiro valor”));
trace(“================”);
trace(“Item anterior: “+minhaMatriz.voltar(“Décimo primeiro valor”));
//FIM DO CÓDIGO

- Inserir um valor numa determinada posição da matriz

1. Siga os passos 1 a 3 do exemplo “Multiplicar elementos de uma matriz” substituindo o código pelo que segue:

//INÍCIO DO CÓDIGO
/* A função incluirItemNaPosicao é definida recebendo dois parâmetros, o item a ser inserido e a sua posição de inserção;
O return devolve a matriz com o item inserido. Vamos analisar com detalhes:
O primeiro slice retorna o pedaço da matriz que vai do 0 (primeiro item) até a posição definida pelo parâmetro índice;
A seguir, o item, que foi enviado para a função para ser inserido;
E finalizando, o segundo slice retorna o pedaço da matriz que vai da posição definida pelo parâmetro índice até o final (comprimento da matriz).
O resultado obtido deve ser esse:
10,20,30,40,50,60 */

Array.prototype.incluirItemNaPosicao = function(item, indice) {
return ([this.slice(0, indice), item, this.slice(indice, this.length)]);
};

var minhaMatriz = [10, 20, 40, 50, 60];
trace(minhaMatriz.incluirItemNaPosicao(30, 2));
//FIM DO CÓDIGO

- Inverte a ordem de uma matriz

1. Siga os passos 1 a 3 do exemplo “Multiplicar elementos de uma matriz” substituindo o código pelo que segue:

//INÍCIO DO CÓDIGO
/* A função gira é criada e receberá um parâmetro;
A variável tmp é criada e definida como uma matriz;
O comprimento da matriz arr é armazenado na variável C;
Um loop for será executado o número de vezes que corresponde ao tamanho da matriz;
O último elemento da matriz é inserido na matriz tmp através do comando tmp.push(arr[C-1]);
O indexador C é decrementado e o loop continua inserindo os valores até chegar ao primeiro elemento.*/
function gira(arr) {
var tmp = new Array();
C = arr.length;
for (i=0; i<arr.length; i++) {
tmp.push(arr[C-1]);
C = C-1;
}
return tmp;
}

/* A matriz matriz é definida e enumerada;
A funcão gira é chamada e o resultado armazenado em matriz;
O trace envia para o painel de saída o resultado obtido.*/
matriz = new Array(5, 10, 15, 20, 25, 30, 35, 40);
matriz = gira(matriz);
trace(matriz);
//FIM DO CÓDIGO

- Loteria configurável

1. Siga os passos 1 a 3 do exemplo “Multiplicar elementos de uma matriz” substituindo o código pelo que segue:

//INÍCIO DO CÓDIGO
/* SIMULAÇÃO DE UM SORTEIO DE LOTERIA
(Escolher, por exemplo, 6 números entre 50 possíveis)*/
// Cria a matriz que armazenará todos números que participarão do sorteio
globo = new Array();
// Cria a matriz que armazenará os números sorteados
sorteados = new Array();
// Aqui é definido o total de números que queremos sortear.
total = 6;
// Define nessa variável a quantidade de números que serão armazenados na matriz que criamos (globo)
qtdSorteados = 50;
// Preenche a matriz globo com todos os números que farão parte do sorteio.
for (i=0; i<total; i++) {
globo[i] = i+1;
}
// Imprime o cabeçalho, pula uma linha e imprime o rótulo “Números no globo” e a relação dos mesmos que estão armazenados na matriz globo.
trace(“LOTERIA SORTE GRANDE \nNúmeros no globo: “+globo);
/* A quantidade de vezes que esse loop será executado é a quantidade de números que serão sorteados (em nosso exemplo, 50)
Math.random( ) gerará “aleatoriamente” um número n, tal que 0 <= n < 1
Math.floor( ) arredondará o resultado para o maior inteiro mais próximo
Os números sorteados são armazenados na respectiva matriz
O número sorteado é retirado da matriz onde os números foram originalmente armazenados
Obs.: Como usamos o trace para a saída, você só verá o funcionamento deste código em ambiente de edição. Procure mudar os valores das variáveis total e qtdSorteados para ver novos sorteios com configurações diferentes. */
for (i=0; i<qtdSorteados; i++) {
rand = Math.floor(Math.random()*(total-i));
sorteados[i] = globo[rand];
globo.splice(rand, 1);
}
trace(“Números sorteados: “+sorteados+”\nRestantes: “+globo);
//FIM DO CÓDIGO

- Retornar o índice do elemento da matriz

//INÍCIO DO CÓDIGO
//Função que gera número aleatório baseado num valor mínimo, máximo e
//quantidade a ser gerada
Array.prototype.gerarNumeroAleatorio = function() {
//Criar os limites
maximo = 10;
minimo = 5;
//Cria a variável que armazenará a quantidade de elementos do espaço
//amostral
faixa = maximo-minimo;
//Define a quantidade de números que serão “sorteados”
quantidade = 4;
//Se quantidade for maior do que a faixa
if (quantidade>((maximo-minimo)+1)) {
//Diminui a quantidade de forma que seu valor seja a da faixa
quantidade = (maximo-minimo)+1;
}
//Criar variáveis de incremento
i = 0;
j = 0;
//Criação e checagem de cada número
//Enquanto i for menor que a quantidade…
while (i<quantidade) {
//Math.random() gera um número n, tal que 0 <= n < 1 e multiplica-o
//pelo valor da (faixa + 1), então o resultado é arredondado e somado
//ao valor de mínimo. Desta maneira, ficamos dentro da faixa.
matrizNumeros[i] = Math.floor(Math.random()*(faixa+1))+minimo;
//Enquanto j for menor do que i…
while (j<i) {
//Se os elementos forem diferentes…
if (matrizNumeros[j] != matrizNumeros[i]) {
//…incremente o j
j++;
}
//…caso contrário, ou seja, se o número já foi usado, o Flash
//criará um novo número e começará novamente…
else {
//Math.random() gera um número n, tal que 0 <= n < 1 e
//multiplica-o pelo valor da (faixa + 1), então o resultado é
//arredondado e somado ao valor de mínimo. Desta maneira,
//ficamos dentro da faixa.
matrizNumeros[i] = Math.floor(Math.random()*(faixa+1))+minimo;
//”Reseta” o valor da variável de incremento
j = 0;
}
}
//Reseta o j e incrementa o i
j = 0;
i++;
}
};
//EXEMPLO
//Definir a matriz de números
matrizNumeros = new Array();
//Rodar a função gerarNumeroAleatorio para a matriz criada
matrizNumeros.gerarNumeroAleatorio();
//Mostrar o resultado no painel de saída
trace(matrizNumeros);
//FIM DO CÓDIGO
Download Fontes

(Fonte: ActionScript.org, adaptado por Francisco Teodorico Pires de Souza)