É mais fácil responder perguntas desse tipo escrevendo pequenos programas usando o suporte a programação funcional e compreensão de lista que algumas linguagens como Python oferecem.

Para contar os zeros de um número, transformamos ele em uma string e contamos quantas substrings ’0′ ele contém. Por exemplo o 800:

str(800).count('0')
# 2

Para gerar uma lista ordenada com os elementos do intervalo entre um e mil, inclusive os valores um e mil:

xrange(1,1001)
# [1, 2, ... , 999, 1000]

Pegamos esse intervalo  e geramos uma outra lista onde cada elemento é a contagem dos zeros do número do intervalo.

[str(x).count('0') for x in xrange(1,1001)]
# [0, 0, ... , 0, 3]

Por exemplo, 1 não tem nenhum zero. Dois também não. 999 também não. 1000 tem três.

Somamos todos os elementos da lista temos o número de algarismos zero entre um e mil.

sum([str(x).count('0') for x in xrange(1,1001)])

E a resposta é 192.

O mesmo poderia ser obtido contando quantos zeros há na representação de string da lista do intervalo.

str(range(1,1001)).count('0')

Mas essa abordagem apesar de menor é menos geral se você quiser modifica-la para contagens mais complexas.

A diferença do range pro xrange é que o range constrói a lista real do intervalo real em memória e o xrange uma representação da lista do intervalo. Em geral mas não sempre, a performasse do xrange é melhor.

De toda forma, em ambos os casos, o resultado é o mesmo.

import java.util.Properties;
 
public class PropertiesLister{
   public static void main (String args[]){
       Properties props = System.getProperties();
       props.list(System.out);
   }
}

In the machine I’m writing right now:

– listing properties –
java.runtime.name=Java(TM) SE Runtime Environment
sun.boot.library.path=/usr/lib/jvm/java-6-sun-1.6.0.00/jre/…
java.vm.version=1.6.0-b105
java.vm.vendor=Sun Microsystems Inc.
java.vendor.url=http://java.sun.com/
path.separator=:
java.vm.name=Java HotSpot(TM) Server VM
file.encoding.pkg=sun.io
user.country=BR
sun.java.launcher=SUN_STANDARD
sun.os.patch.level=unknown
java.vm.specification.name=Java Virtual Machine Specification
user.dir=/tmp
java.runtime.version=1.6.0-b105
java.awt.graphicsenv=sun.awt.X11GraphicsEnvironment
java.endorsed.dirs=/usr/lib/jvm/java-6-sun-1.6.0.00/jre/…
os.arch=i386
java.io.tmpdir=/tmp
line.separator=

java.vm.specification.vendor=Sun Microsystems Inc.
os.name=Linux
sun.jnu.encoding=UTF-8
java.library.path=/usr/lib/jvm/java-6-sun-1.6.0.00/jre/…
java.specification.name=Java Platform API Specification
java.class.version=50.0
sun.management.compiler=HotSpot Server Compiler
os.version=2.6.20-16-generic
user.home=/home/export/silveira
user.timezone=
java.awt.printerjob=sun.print.PSPrinterJob
file.encoding=UTF-8
java.specification.version=1.6
user.name=silveira
java.class.path=.
java.vm.specification.version=1.0
sun.arch.data.model=32
java.home=/usr/lib/jvm/java-6-sun-1.6.0.00/jre
java.specification.vendor=Sun Microsystems Inc.
user.language=pt
java.vm.info=mixed mode
java.version=1.6.0
java.ext.dirs=/usr/lib/jvm/java-6-sun-1.6.0.00/jre/…
sun.boot.class.path=/usr/lib/jvm/java-6-sun-1.6.0.00/jre/…
java.vendor=Sun Microsystems Inc.
file.separator=/
java.vendor.url.bug=http://java.sun.com/cgi-bin/bugreport…
sun.cpu.endian=little
sun.io.unicode.encoding=UnicodeLittle
sun.cpu.isalist=

Try out at your home. :)

A SCJA (Sun Certified Java Associate) é a certificação Java de nível de entrada. Como ela não é pre-requisito para nenhuma outra certificação poucas pessoas tiram a SCJA. Apesar disso eu a acho uma certificação interessante porque ela é bem abrangente, embora que superficial. Eu estou estudando para SCJA como uma porta de entrada para as outras certificações.

Este post é uma coletânea de links e dicas úteis para aqueles que possuirem estes mesmo objetivos.

• Página oficial da SCJA – nesta página estão as principais informações sobre a certificação, algumas referencias de material para estudo e os objetivos do exame, que é a primeira coisa que você deve ler. Se possível imprima os objetivos do exame e vá marcando os objetivos que você já estudou.
• UML for the Java Associate – Esse é um PDF gratuito que cobre alguns conceitos básicos de UML em uma linguagem fácil de divertida. Eu gostaria de ter tido isso em mãos alguns semestres atrás. O autor é o Dave Wood (que também elabora provas da SCJA) e é da mesma editora da série Head First. Esse livrinho é um ótimo ponto de partida para começar a estudar.
• JavaRanch SCJA FAQ – Um tira dúvidas das dúvidas comuns sobre o SCJA e também uma excelente coletânea de materiais de estudo.
• J2EE Specification – Um dos objetivos da é “Java Platforms and Integration Technologies“. Vá nesse PDF J2EE Specification, na seção 2.6 há um ótimo guia de termos de J2EE.
• Trail: Learning the Java Language – Trilha de aprendizado da página oficial de tutoriais do Java. Muito bom e completo.

Objetivos da Certificação SCJA

Essa tradução fui em quem fiz, não é oficial. Se encontrar algum erro me notifique nos comentários do post.

• Seção 1 – Conceitos Fundamentais de Orientação a Objetos.
  • Descrever, comparar e contrastar primitivas (inteiro, ponto flutuante, booleano, e caractere), tipos enumerados e objetos.
  • Descrever, comparar e contrastar classes concretas, classes abstratas, e interfaces, e como a herança se aplica a elas.
  • Descrever, comparar e contrastar composição de classes, e associações (inclusive de multiplicidade um-para-um, um-para-muitos e muitos-para-muitos) e associações de navegação.
  • Descrever ocultamento de informação (usando atributos privados e métodos), encampsulamento e exposição de funcionalidades de objetos usando métodos públicos; e descrever as convenções de JavaBeans para métodos setter e getter.
  • Descrever polimorfismo aplicado a classes e interfaces, e descrever e aplicar o princípio de “programar para uma interface”.
• Seção 2 – Representação UML de Conceitos de Orientação a Objetos.
  • Reconhecer as representações UML de classes, (incluindo atributos e operações, classes abstratas, e interfaces), as representações UML de herança (ambas implementações e interface), e a representação UML de modificadores de visibilidades de membros de classe (- para privado e + para público).
  • Reconhecer a presetação UML de associação de classe, composição, indicadores de multiplicidade da associação, e indicadores de navegação da associação.
• Seção 3 – Implementação Java de Conceitos de Orientação a Objetos.
  • Nota: exemplos de código podem usar o operador “new“.
  • Desenvolver código que use tipos primitivos, tipos enumerados, e referencias a objetos, e reconhecer os literais desses tipos.
  • Desenvolver código que declare classes concretas, classes abstratas, e interfaces, código que suporte implementação e interfaces de herança, código que declare atributos de instância e métodos, e código que use os modificadores de acesso: private e public.
  • Desenvolver código que implemente associação de classes simples, código que implemente multiplicidade usando vetores, e reconhecer código que implemente composição em detrimento de simples associações, e código que implementa associações de navegação corretamente.
  • Desenvolver código que use polimorfismo tanto para classes quanto para interfaces, e reconhecer código que usa o princípio de “programar para uma interface”
• Seção 4 – Projeto e Implementação de Algoritmos.
  • Descrever, comparar e contrastar estes três tipos fundamentais de sentenças: atribuição, condicional, e iteração, e dado uma descrição de um algoritmo, selecionar os tipos apropriados de sentenças para projetar o algoritmo.
  • Dado um algoritmo em pseudo-código, terminar o escopo correto para a variável usada no algoritmo, e desenvolver código que declara variáveis em qualquer um dos seguintes escopos: variável de instância, parâmetro de método, e variável local.
  • Dado um algoritmo em pseudo-código, desenvolver um código de método que implementa o algoritmo usando sentenças condicionais (if e switch), sentenças de iteração (for, for-each, while, e do-while), sentenças de atribuição, e sentenças break e continue para controlar o fluxo no switch e nas sentenças de iteração.
  • Dado um algoritmo e múltiplas entradas e saídas, desenvolver o código do método que implementa o algoritmo usando os parâmetros de métodos, um tipo de retorno, e uma sentença de retorno, e reconhecer os efeitos quando referencias a objetos e primitivas são passadas para métodos que os modificam.
  • Dado um algoritmo em pseudo-código, desenvolver código que aplica corretamente e apropriadamente os operadore incluíndo os operadores de atribuição (limitados a: =, +=, -=), operadores aritméticos (limitados a: +, -, *, /, %, ++, –), operadores relacionais (limitados a: <, <=, >, >=, ==, !=), operadores lógicos (limitados a: !, &&, ||) para produzir o resultado desejado. Também escrever código que determina a igualdade de dois objetos ou duas primitivas.
  • Desenvolver código que usa o operador de concatenação (+), e os seguintes métodos da classe String: charAt, indexOf, trim, substring, replace, length, startsWith, e endsWith.
• Seção 5 – Fundamentos de Desenvolvimento Java.
  • Descrever os propósitos de pacotes (packages) na linguagem Java, e reconhecer o uso correto de sentenças de import e package.
  • Demonstrar o uso correto do comando “javac” (inclusive as opções de linha de comando: -d e -classpath), e demonstrar o uso correto do comando “java” (inclusive as opções de linha de comando: -classpath, -D e -version).
  • Descrever os propósitos e tipos de classes dos seguintes pacotes Java: java.awt, javax.swing, java.io, java.net, java.util.
• Seção 6 – Tecnologias Java de Plataforma e Integração.
  • Distinguir as características básicas das três plataformas Java: J2SE, J2ME, e J2EE, e dado objetivos arquitetônicos de alto nível, selecionar a(s) plataforma(s) apropriada(s).
  • Descrever em um alto nível os benefícios e as características básicas do RMI.
  • Descrever em um alto nível os benefícios e as características básicas das tecnologias JDBC, SQL e RDBMS.
  • Descrever em um alto nível os benefícios e as características básicas das tecnologias JNDI, mensagem, e JMS.
• Seção 7 – Tecnologias Cliente.
  • Descrever em um alto nível as características básicas, benefícios e inconvenientes de criar thin-clients usando HTML e JavaScript e os problemas e soluções relacionadas à distribuição.
  • Descrever em um alto nível as características básicas, benefícios, inconvenientes e os problemas de distribuição relacionados a criação de clientes usando J2ME.
  • Descrever em um alto nível as características básicas, benefícios, inconvenientes e os problemas de distribuição relacionados a criação de fat-clients usando Applets.
  • Descrever em um alto nível as características básicas, benefícios, inconvenientes e os problemas de distribuição relacionados a criação de fat-clients usando Swing.
• Seção 8 – Tecnologias Servidor.
  • Descrever em um alto nível as características básica de: EJB, servlets, JSP, JMS, JNDI, SMTP, JAX-RPC, Web Services (incluindo SOAP, UDDI, WSDL, e XML), e JavaMail.
  • Descrever em um alto nível as características básicas de servlet e o suporte JSP para thin-clients HTML.
  • Descrever em um alto nível o uso e as características básicas de uma seção EJB, beans de entidade e beans orientados a mensagem (message-driven).
  • Descrever em uum alto nível os benefícios fundamentais e inconvenientes de usar tecnologias do lado do servidor J2EE e descrever e comparar as características básicas da camada web, camada de negócios e a camada EIS.

Simulados SCJA gratuitos

• scja.de – na lateral esquerda, tem uns botões azuis. Cada um deles é uma bateria de questões.
• ejavaguru.com – 10 questões de SCJA.
• cafe4java.com – 5 questões sobre SCJA.
• WGS-PREX-J019C – Esse é o melhor teste que eu já vi. É o teste oficial da Sun, com 150 questões e é um teste pago e o valor varia de país para país. O que certamente você não sabe é que esse teste está disponível gratuitamente, só que neste site bem escondido. Você vai lá, se cadastra e recebe um link, login e senha. O ambiente não é tão bom quanto o Sun Learning Connection mas as questões são as mesmas. Inclusive nesse mesmo pacote tem testes para várias outras certificações, tudo de graça e dentro da lei. :)

Eu estou incrementando e organizando esse post aos poucos.

import javafx.ui.*;
import javafx.ui.canvas.*;

Canvas {
    content: Circle {
        var x = 50
        var y = 50
        transform: bind translate(x, y)
        radius: 30
        fill: red
        onMouseDragged: operation(e) {
                x += e.localDragTranslation.x;
                y += e.localDragTranslation.y;

        }
    }
}

import javafx.ui.*;
import javafx.ui.canvas.*;

Canvas {
    content: Circle {
        var x = 50
        var y = 50
        var radius = 30
        transform: bind translate(x, y)
        radius: bind radius
        fill: red
        onMouseDragged: operation(e) {
            if (e.button == 1){
                x += e.localDragTranslation.x;
                y += e.localDragTranslation.y;
            }
            if (e.button == 3) {
                radius += e.localDragTranslation.x;
            }
        }
    }
}

import javafx.ui.*;
import javafx.ui.canvas.*;

Canvas {
    content: [
    Rect {x: 50, y: 50, width: 50, height: 50, fill: orange },
    Circle {
        var x = 50
        var y = 50
        var radius = 30
        var color = red:Color
        transform: bind translate(x, y)
        radius: bind radius
        fill: bind color
        onMouseDragged: operation(e) {
            if (e.button == 1){
                x += e.localDragTranslation.x;
                y += e.localDragTranslation.y;
            }
            if (e.button == 3) {
                radius += e.localDragTranslation.x;
            }
        }
        onMousePressed: operation(e){
            color = Color {blue: 0.0, green: 0.0, red: 1.0, opacity: 0.5};
        }
        onMouseReleased: operation(e){
            color = red:Color;
        }
    }]
}

You can test this examples with thhe JavaFX Pad or using Netbeans with the JavaFX Plugin.

Esse exemplo cria uma classe Estatistica com o método media que pode receber um número variável de argumentos do tipo int.

public class Estatistica {
    public float media(int... numeros){
        float soma = 0;
        for(int num: numeros)
            soma += num;
        return soma/numeros.length;
    }
    public static void main(String[] args) {
        Estatistica est = new Estatistica();
        System.out.println( est.media(1,2,3) );
        System.out.println( est.media(0,1,2,3,4,5,6,7,8,9,10) );
        System.out.println( est.media(10,20,30) );
    }
}

$ javac Estatistica.java
$ java Estatistica
2.0
5.0
20.0

Legal, né? Isso sim é sobrecarga de método. ;)

% Fatos.
homer.
marge.
bart.
lisa.
maggie.
mona.
jacqueline.
patty.
abraham.
clancy.
hugo.
louise.
herb.
 
mulher(marge).
mulher(maggie).
mulher(lisa).
mulher(mona).
mulher(clancy).
mulher(jacqueline).
mulher(selma).
mulher(patty).
mulher(louise).
 
homem(homer).
homem(bart).
homem(abraham).
homem(clancy).
homem(hugo).
homem(herb).
 
progenitor(homer,bart).
progenitor(homer,lisa).
progenitor(homer,maggie).
progenitor(marge,bart).
progenitor(marge,lisa).
progenitor(marge,maggie).
 
progenitor(abraham, homer).
progenitor(mona, homer).
 
progenitor(clancy, marge).
progenitor(clancy, patty).
progenitor(clancy, selma).
progenitor(jacqueline, marge).
progenitor(jacqueline, patty).
progenitor(jacqueline, selma).
 
progenitor(abraham, herb).
 
progenitor(herb, hugo).
progenitor(louise, hugo).
 
% Regras
pai(A,B) :- homem(A), progenitor(A,B).
mãe(A,B) :- mulher(A), progenitor(A,B).
 
é_pai(A) :- pai(A,_).
é_mãe(A) :- mãe(A,_).
 
filho(A,B):- homem(A), progenitor(B,A).
filha(A,B):- mulher(A), progenitor(B,A).
 
irmaos(X,Y) :-
	progenitor(Z,X),
	progenitor(Z,Y),
	X\=Y.
 
irmao_completos(A,B) :-
	pai(P,A), pai(P,B),
	mãe(M,A), mãe(M,B),
	A\=B.
 
tio(T,A) :-
	homem(T),
	irmaos(T,X), progenitor(X,A).
 
tia(T,A) :-
	mulher(T),
	irmaos(T,X), progenitor(X,A).
 
primo(A,B) :-
	homem(A),
	progenitor(X,A),
	progenitor(Y,B),
	irmaos(X,Y).
 
prima(A,B) :-
	mulher(A),
	progenitor(X,A),
	progenitor(Y,B),
	irmaos(X,Y).
 
avô(A,B) :- pai(A,X), pai(X,B).
avó(A,B) :- pai(A,X), pai(X,B).

Referências:

• Simpsons Family
• Genealogy Database, Guide to Prolog Programming

Só quero pegar um monte de fotos de várias resoluções diferentes e gerar uma página em HTML com as miniaturas das imagens com largura de 500 pixeis e com o link para a imagem original. É uma implementação bem simples, sem muita sofisticação. Eu coloco aqui porque ele é fácil de adaptar para outros usos.

#!/usr/bin/env python
import os
import Image
 
cwd = os.getcwd()
for arquivo in os.listdir(cwd):
   if arquivo.endswith('.JPG'):
      im = Image.open(arquivo)
      im.thumbnail((500,375), Image.ANTIALIAS)
      nome = arquivo.split('.')[0]
      tnome = nome + "_thumb.jpg"
      im.save(tnome, "JPEG")
      print '<a href="%s"><img src="%s"/></a><br/>' % (arquivo, tnome)

Ele procura os arquivos do diretório que terminam com .JPG, cria uma miniatura de tamanho 500 por 375 e cospe o HTML na saída padrão. Para usar ele, entre no terminal do diretório onde você quer fazer a galeria e execute o script:

python galeria.py > saida.html

Ele cria galerias bem simples como essa ou essa.

Esse sábado eu participei, junto com o Carlos Pontual e o Heraldo Carneiro, da décima segunda edição da Maratona Brasileira de Programação.

A sede do Ceará na competição ia ser em Sobral, com o pessoal da Engenharia da Computação da UFC, mas acabou sendo na Unifor. Uma pena, eu queria ter viajado pra conhecer o curso novo.

Embora antigamente eu tenha competido na OBI (Olimpíada Brasileira de Informática), eu nunca havia competido na Maratona Brasileira de Computação. Enquanto a OBI é uma competição voltada para alunos do ensino médio e básico a maratona é voltada para alunos do ensino superior da graduação e mestrado. Pelas minhas contas já faziam aí uns 3 anos que eu não competia.

Para quem não conhece esse tipo de competição, funciona assim: uma pessoa ou uma equipe (dependendo da competição) tem um certo tempo para resolver uma série de problemas usando programação. A correção do programa é automatizada. Seu programa é testado através de uma bateria de testes e deve retornar as respostas corretas. É uma ótima forma de melhorar seus conhecimentos sobre grafos, lógica, programação dinâmica, estruturas de dados, programação etc. Também é uma ótima oportunidade para conhecer ou rever o pessoal dos cursos de computação.

Bem, vamos aos problemas que nós fizemos:

• Varetas, problema H, era um problema bem simples. Esse nós fizemos em C e foi aceito de primeira.

• Histórico, problema E, também um problema não muito complicado. Mas foi por ele que nós nos enrolamos. Nós resolvemos o problema em Java e submetemos, mas a correção deu runtime error para ele. Nós re analisamos o problema, modificamos o programa e mandamos novamente e ganhamos outro runtime error. Como nós estávamos bem confiantes que nossa resposta estava certa nós refizemos o programa em C e submetemos. Dessa vez o programa passou sem problemas. Mais Tarde ficamos sabendo que devido a um erro da correção automática, não havia como um programa em Java ter acertado essa questão. Isso fez que passemos 1 hora e 44 minutos nesse problema.

• Rouba, problema B, basicamente um problema para simular um jogo de cartas. O Heraldo pegou esse problema e fez ele em Java. Depois de 3 submissões e 3 time limit exceeded da correção automática, nós estávamos certos que nosso programa estava correto. Nós já haviamos feitas varias otimizações de velocidade no programa. Havia agora três alternativas: ou abandonar o problema e tentar outra questão ou continuar a otimizar o programa ou refaze-lo em C. Até tentamos sair do problema, mas ele não saiu da cabeça do Heraldo :). Refaze-lo em C implicaria em implementar uma série de estruturas na unha, o que iria ser muito chato e não havia certeza que isso ia resolver nossa vida.Por fim o Heraldo fez mais um última pequena otimização no programa e ele passou.

Nós ainda tentamos sem sucesso resolver os problemas Mário (o problema do armário hehehe) e o Zak.

Algumas estatísticas (parciais) da sede do Ceará:

Equipes e problemas resolvidos:

Observações: A equipe Singularidade de Sobral não estava presente lá, eu não sei se eles competiram. As equipes da UECE tiveram a boa idéia de colocar o nome da faculdade no nome da equipe.

Eu gostei muito dos resultados. Tivemos muitas equipes com bons resultados. Isso demonstra que os esforços, principalmente do Joel Uchôa, em divulgar e particularizar a competição estão sendo frutíferos. Todas as universidades conseguiram bons resultados. Ano que vem eu espero ver mais universidades competindo.

Sugestões para a organização:

• Linguagens: segundo o Joel Uchôa me informou há planos para inserir novas linguagens na competição. Fica minha sugestão para que Python e Ruby sejam incluídas.
• Java: me parece que há um longo histórico de problemas com a correção de programas em Java, sendo inclusive o uso desta desaconselhado por alguns. Eu espero que isso seja melhorado na próxima edição. Eu e minha equipe tivemos sérios problemas por conta disso mas nem por isso tenho planos de usar outra linguagem na próxima edição.
• Distribuição: há uma distribuição GNU/Linux própria para a competição o Maratona Linux. Ele tem várias sacadas legais como redes separadas para que nenhuma equipe possa usar a Internet ou enxergar as outras equipes, boot remoto etc. Porém é necessário boot pelo disquete o que tem sido uma fonte constante de problemas. O sistema de janelas WindowMaker também é fonte de confusão com usuários iniciantes, se é realmente necessário um sistema minimalista eu recomendaria o Fluxbox, XFCE ou Icewm.
• Correção: eu não gosto do esquema de correção da Maratona. Eu prefiro o da OBI. Na OBI há varias baterias de testes, cuidadosamente preparadas para filtrar cada tipo de erro ou algoritmos. Cada acerto em uma bateria resulta em pontuação. Já na maratona ou se acerta uma questão completamente ou ela está totalmente errada. Isso impede algoritmos mais triviais, algoritmos com complexidade alta (os não polinomiais) e impede também usar técnicas de Inteligência Artificial. Acho que isso interfere muito na forma de se elaborar os problemas e de se resolver os problemas. No universo dos problemas reais, nem tudo pode ser resolvido em tempo e espaço polinomial. Esse é o universo em que vivemos.

Fotos:

A Maratona Brasileira de Programação é uma realização da Sociedade Brasileira de Computação, USP, Fundação Carlos Chagas, IBM e diversas universidades e voluntários por todo o Brasi.

Criando e acessando um vetor

var planetas = new Array()
planetas[0] = "Mercúrio"
planetas[1] = "Vênus"
planetas[2] = "Terra"
planetas[3] = "Marte"
planetas[4] = "Júpiter"
planetas[5] = "Saturno"
planetas[6] = "Urano"
planetas[7] = "Neptuno"
 
for (i=0;i

Que vai escrever isso:

Mercúrio
Vênus
Terra
Marte
Júpiter
Saturno
Urano
Neptuno

Iterando no vetor

var planetas = new Array()
planetas[0] = "Mercúrio"
planetas[1] = "Vênus"
planetas[2] = "Terra"
planetas[3] = "Marte"
planetas[4] = "Júpiter"
planetas[5] = "Saturno"
planetas[6] = "Urano"
planetas[7] = "Neptuno"
 
for (i in planetas){
    document.write(planetas[i] + "")
}

vai retornar a mesma saída do primeiro programa:

Que vai escrever isso:

Mercúrio
Vênus
Terra
Marte
Júpiter
Saturno
Urano
Neptuno

Concatenando dois vetores

var litoral = new Array()
litoral[0] = "Jericoacoara"
litoral[1] = "Paracuru"
litoral[2] = "Tabuba"
 
var sertao = new Array()
sertao[0] = "Itapipoca"
sertao[1] = "Ubajara"
sertao[2] = "Juazeiro"
 
var ceara = litoral.concat(sertao)
 
document.write(litoral+"
")
document.write(sertao+"
")
document.write(ceara+"
")

Jericoacoara,Paracuru,Tabuba
Itapipoca,Ubajara,Juazeiro
Jericoacoara,Paracuru,Tabuba,Itapipoca,Ubajara,Juazeiro

Unindo os elementos de um vetor

var letras = new Array(3)
letras[0] = "A"
letras[1] = "B"
letras[2] = "C"
document.write(letras.join() + "")
document.write(letras.join("@"))

A,B,C
A@B@C

Ordenação Literal

Essa ordenação é feita sem usar nenhum parâmetro, então a ordem lexicográfica, a do dicionário.

var coisas = new Array(4)
coisas[0] = "casa"
coisas[1] = "bonde"
coisas[2] = "alvo"
coisas[3] = "dado"
 
document.write(coisas + "")
document.write(coisas.sort()+ "")
document.write(coisas + "")

Note que depois do .sort() o vetor é alterado.

casa,bonde,alvo,dado
alvo,bonde,casa,dado
alvo,bonde,casa,dado

Ordenação usando uma função de ordenação

A ordenação literal não vai funcionar bem nesse caso, então nos definimos uma função para ordenação. Ela deve retornar zero se ambos forem iguais, um número positivo se o primeiro for maior que o segundo e um número negativo se o segundo for maior que o primeiro.

function sortNumber(a, b){
return a - b
}
 
var arr = new Array(6)
arr[0] = "10"
arr[1] = "5"
arr[2] = "40"
arr[3] = "25"
arr[4] = "1000"
arr[5] = "1"
 
document.write(arr + "")
document.write(arr.sort()+"
")
document.write(arr.sort(sortNumber))

10,5,40,25,1000,1
1,10,1000,25,40,5
1,5,10,25,40,1000

Retirando o último elemento

O pop retorna o último elemento do vetor e o retira.

var gatos = new Array(3)
gatos[0] = "Frida"
gatos[1] = "Sauber"
gatos[2] = "Boris"
document.write(gatos + "")
document.write(gatos.pop() + "")
document.write(gatos)

Frida,Sauber,Boris
Boris
Frida,Sauber

Inserindo elementos no final do vetor

O push insere um elemento no final do vetor e retorna seu novo tamanho.

var animais = new Array(3)
animais[0] = "Frida"
animais[1] = "Sauber"
animais[2] = "Frida"
document.write(animais + "")
document.write(animais.push("Vida")+ "")
document.write(animais)

Frida,Sauber,Frida
4
Frida,Sauber,Frida,Vida

Inserindo elementos no inicio do vetor

var inst = new Array(3)
inst[0] = "Baixo"
inst[1] = "Guitarra"
inst[2] = "Piano"
document.write(inst + "")
document.write(inst.unshift("Flauta") + "")
document.write(inst)

Baixo,Guitarra,Piano
4
Flauta,Baixo,Guitarra,Piano

Retirando elemento no inicio do vetor

var inst = new Array(3)
inst[0] = "Baixo"
inst[1] = "Guitarra"
inst[2] = "Piano"
 
document.write(inst + "")
document.write(inst.shift() + "")
document.write(inst)

Baixo,Guitarra,Piano
Baixo
Guitarra,Piano