diff options
Diffstat (limited to 'pt-br')
| -rw-r--r-- | pt-br/amd.html.markdown | 2 | ||||
| -rw-r--r-- | pt-br/binary-search-pt.html.markdown | 77 | ||||
| -rw-r--r-- | pt-br/c-pt.html.markdown | 2 | ||||
| -rw-r--r-- | pt-br/clojure-macros-pt.html.markdown | 2 | ||||
| -rw-r--r-- | pt-br/dynamic-programming-pt.html.markdown | 76 | ||||
| -rw-r--r-- | pt-br/elixir.html.markdown | 1 | ||||
| -rw-r--r-- | pt-br/elm-pt.html.markdown | 384 | ||||
| -rw-r--r-- | pt-br/git-pt.html.markdown | 2 | ||||
| -rw-r--r-- | pt-br/julia-pt.html.markdown | 748 | ||||
| -rw-r--r-- | pt-br/python3-pt.html.markdown | 2 | ||||
| -rw-r--r-- | pt-br/self-pt.html.markdown | 165 | ||||
| -rw-r--r-- | pt-br/swift-pt.html.markdown | 2 | ||||
| -rw-r--r-- | pt-br/vim-pt.html.markdown | 239 |
13 files changed, 1697 insertions, 5 deletions
diff --git a/pt-br/amd.html.markdown b/pt-br/amd.html.markdown index 690fc8da..38c1f70f 100644 --- a/pt-br/amd.html.markdown +++ b/pt-br/amd.html.markdown @@ -5,7 +5,7 @@ contributors: - ["Frederik Ring", "https://github.com/m90"] translators: - ["Felipe Tarijon", "http://nanoincub.com/"] -lang: ptr-br +lang: pt-br filename: learnamd-pt.js --- diff --git a/pt-br/binary-search-pt.html.markdown b/pt-br/binary-search-pt.html.markdown new file mode 100644 index 00000000..d3060506 --- /dev/null +++ b/pt-br/binary-search-pt.html.markdown @@ -0,0 +1,77 @@ +--- +category: Algorithms & Data Structures +name: Binary Search +contributors: + - ["Abhishek Jaisingh", "http://github.com/abhishekjiitr"] +translators: + - ["Claudson Martins", "https://github.com/claudsonm"] +lang: pt-br +--- + +# Busca Binária + +## Por Que Busca Binária? + +Operações de busca são um dos principais problemas na Ciência da Computação. +Atualmente existem mais de 1 trilhão de buscas por ano, e nós precisamos de +algoritmos que possam realizá-las rapidamente. Busca binária é um dos algoritmos +fundamentais em ciência da computação. A fim de explorá-la, iremos primeiro +construir um conhecimento teórico, e então utilizá-lo para implementar o +algoritmo apropriadamente. + +## Introdução + +Uma abordagem simples para implementar uma busca é realizar uma busca linear, +mas algoritmos nessa abordagem levam muito tempo, o qual cresce linearmente de +acordo com a quantidade ou número de dados. Por exemplo, iniciando do elemento +mais a esquerda de arr[] e um a um comparar x com cada elemento de arr[], se x +coincide com um elemento, retornar seu índice. Se x não coincide com nenhum dos +elementos, retornar -1. + +``` +Busca Linear: O (n) Tempo Linear + +Busca Binária: O ( log(n) ) Tempo Logarítmico + +``` +``` +def busca(arr, x): + + for i in range(len(arr)): + + if arr[i] == x: + return i + + return -1 + +``` +## Algoritmo de Busca Binária + +O pré-requisito básico para que uma busca binária funcione é que os dados que se +desejam buscar devem estar ordenados (em qualquer ordem). + +### Pseudocódigo + +``` +A ideia da busca binária é usar a informação de que o array está ordenado e +reduzir a complexidade de tempo para O(Log n). Nós basicamente ignoramos metade +dos elementos após uma comparação. + +1) Compare x com o elemento do meio. +2) Se x coincide com o elemento do meio, retorne o índice do meio. +3) Senão Se x é maior que o elemento do meio, então x só pode estar no lado +direito do elemento do meio. Portanto nós pulamos para a metade direita. +4) Senão (x é menor) pulamos para a metade esquerda. + +Essa é a ideia da implementação recursiva da busca binária. + +``` + +### Considerações Finais + +Existem outras formas de busca binária que são muito úteis. + +## Recursos Online + +* [GeeksforGeeks](http://www.geeksforgeeks.org/the-ubiquitous-binary-search-set-1/) +* [Topcoder Tutorial](https://www.topcoder.com/community/data-science/data-science-tutorials/binary-search/) diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown index 2c274f12..0af553c8 100644 --- a/pt-br/c-pt.html.markdown +++ b/pt-br/c-pt.html.markdown @@ -28,7 +28,7 @@ Funcionam no C89 também. */ // Constantes: #define <palavra-chave> -#definie DAY_IN_YEAR 365 +#define DAY_IN_YEAR 365 //enumerações também são modos de definir constantes. enum day {DOM = 1, SEG, TER, QUA, QUI, SEX, SAB}; diff --git a/pt-br/clojure-macros-pt.html.markdown b/pt-br/clojure-macros-pt.html.markdown index dbc0c25c..d56840e0 100644 --- a/pt-br/clojure-macros-pt.html.markdown +++ b/pt-br/clojure-macros-pt.html.markdown @@ -142,6 +142,8 @@ Você vai querer estar familiarizado com Clojure. Certifique-se de entender tudo (inline-2 (1 + (3 / 2) - (1 / 2) + 1)) ; -> 3 (Na verdade, 3N, desde que o numero ficou convertido em uma fração racional com / +``` + ### Leitura adicional Escrevendo Macros de [Clojure para o Brave e True](http://www.braveclojure.com/) diff --git a/pt-br/dynamic-programming-pt.html.markdown b/pt-br/dynamic-programming-pt.html.markdown new file mode 100644 index 00000000..8de9bee6 --- /dev/null +++ b/pt-br/dynamic-programming-pt.html.markdown @@ -0,0 +1,76 @@ +--- +category: Algorithms & Data Structures +name: Dynamic Programming +contributors: + - ["Akashdeep Goel", "http://github.com/akashdeepgoel"] +translators: + - ["Claudson Martins", "https://github.com/claudsonm"] +lang: pt-br +--- + +# Programação Dinâmica + +## Introdução + +Programação Dinâmica é uma técnica poderosa utilizada para resolver uma classe +particular de problemas como veremos. A ideia é bastante simples, se você +solucionou um problema com uma dada entrada, então salve o resultado para +referência futura, e também para evitar resolver o mesmo problema novamente. + +Sempre se lembre!! +"Aqueles que não conseguem lembrar o passado estão condenados a repeti-lo" + +## Maneiras de Solucionar tais Problemas + +1. Top-Down (De cima para baixo): Começe solucionando o problema quebrando-o em +partes. Se você perceber que o problema já foi resolvido, então simplemente +pegue a resposta salva. Se ainda não foi resolvido, solucione-o e salve a +resposta. Isso é geralmente fácil de pensar e muito intuitivo. É geralmente +referenciado como Memorização. + +2. Bottom-Up (De baixo para cima): Analise o problema e veja a ordem em que os +subproblemas são resolvidos e começe a solucionar dos problemas mais triviais, +até o problema dado. Neste processo, é garantido que os subproblemas são +resolvidos antes de resoler o problema. Isto é referenciado como Programação Dinâmica. + +## Exemplo de Programação Dinâmica + +O problema da subsequência crescente máxima consiste em encontrar a maior +subsequência crescente de uma dada sequência. Dada uma sequência +S= {a1 , a2 , a3, a4, ... , an-1, an} nós temos que encontrar o maior subconjunto +de forma que para todo j e i, j < i no subconjunto aj < ai. Antes de mais nada +nós temos que encontrar o valor das maiores subsequências (LSi) para cada índice +i com o último elemento da sequência sendo ai. Então a maior LSi será a maior +subsequência na sequência dada. Para começar LSi é atribuído a um pois ai é +elemento da sequência (último elemento). Então para todo j tal que j < i e aj < +ai, nós procuramos o maior LSj e o adicionamos a LSi. Portanto o algoritmo tem +complexidade de tempo O(n2). O pseudocódigo para procurar o comprimento da +subsequência crescente máxima: A complexidade desse algoritmo poderia ser +reduzida utilizando uma estrutura de dados melhor que um array. Armazenando o +array antecedente e uma variável como maiorSequenciasAteAgora e seu índice +ajudariam a poupar muito tempo. +Um conceito similar poderia ser aplicado ao procurar o maior caminho em um +grafo acíclico dirigido. +--------------------------------------------------------------------------- +``` + for i=0 to n-1 + LS[i]=1 + for j=0 to i-1 + if (a[i] > a[j] and LS[i]<LS[j]) + LS[i] = LS[j]+1 + for i=0 to n-1 + if (largest < LS[i]) +``` + +### Alguns Problemas Famosos de Programação Dinâmica +``` +Floyd Warshall Algorithm - Tutorial and C Program source code:http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code + +Integer Knapsack Problem - Tutorial and C Program source code: http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem + +Longest Common Subsequence - Tutorial and C Program source code : http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence +``` + +## Recursos Online (EN) + +* [codechef](https://www.codechef.com/wiki/tutorial-dynamic-programming) diff --git a/pt-br/elixir.html.markdown b/pt-br/elixir.html.markdown index b4ca8a52..f8c56101 100644 --- a/pt-br/elixir.html.markdown +++ b/pt-br/elixir.html.markdown @@ -5,6 +5,7 @@ contributors: - ["Dzianis Dashkevich", "https://github.com/dskecse"] translators: - ["Rodrigo Muniz", "http://github.com/muniz95"] +lang: pt-br filename: learnelixir-pt.ex --- diff --git a/pt-br/elm-pt.html.markdown b/pt-br/elm-pt.html.markdown new file mode 100644 index 00000000..78a4f1b7 --- /dev/null +++ b/pt-br/elm-pt.html.markdown @@ -0,0 +1,384 @@ +--- +language: Elm +contributors: + - ["Max Goldstein", "http://maxgoldste.in/"] +translators: + - ["Marcel dos Santos", "https://twitter.com/marcelgsantos"] +lang: pt-br +filename: learnelm-pt.elm +--- + +Elm é uma linguagem de programação funcional reativa que compila para (client-side) +JavaScript. Elm é estaticamente tipada, significando que o compilador captura a +maioria dos erros imediatamente e fornece uma mensagem de erro limpa e compreensível. +Elm é excelente para projetar interfaces de usuário e jogos para a web. + + +```haskell +-- Comentários de uma linha começam com dois traços. +{- Comentários de múltiplas linhas podem ser delimitados em um bloco como este. +{- Eles podem ser aninhados. -} +-} + +{-- O Básico --} + +-- Operações Aritméticas +1 + 1 -- 2 +8 - 1 -- 7 +10 * 2 -- 20 + +-- Cada número literal sem um ponto decimal pode ser um Int ou um Float. +33 / 2 -- 16.5 com divisão de ponto flutuante +33 // 2 -- 16 com divisão inteira + +-- Exponenciação +5 ^ 2 -- 25 + +-- Booleanos +not True -- False +not False -- True +1 == 1 -- True +1 /= 1 -- False +1 < 10 -- True + +-- Strings e caracteres +"Esta é uma string porque ela utiliza aspas duplas." +'a' -- caracteres entre aspas simples + +-- Strings podem ser anexadas. +"Olá " ++ "mundo!" -- "Olá mundo!" + +{-- Listas, Tuplas e Registros --} + +-- Cada elemento em uma lista deve ter o mesmo tipo. +["the", "quick", "brown", "fox"] +[1, 2, 3, 4, 5] +-- O segundo exemplo também pode ser escrito com dois pontos. +[1..5] + +-- Junte listas da mesma forma que strings. +[1..5] ++ [6..10] == [1..10] -- True + +-- Para adicionar um item utilize "cons". +0 :: [1..5] -- [0, 1, 2, 3, 4, 5] + +-- A cabeça e a cauda de uma lista são retornadas como uma Maybe. Em vez de +-- verificar cada valor para ver se ele é nulo, você lida com os valores +-- faltantes explicitamente. +List.head [1..5] -- Just 1 +List.tail [1..5] -- Just [2, 3, 4, 5] +List.head [] -- Nothing +-- List.functionName siginifica que a função faz parte do módulo List. + +-- Cada elemento em uma tupla pode ser de um tipo diferente, mas uma tupla +-- tem um comprimento fixo. +("elm", 42) + +-- Acesse os elementos de um par com as funções first e second. +-- (Este é um atalho; nós iremos para o "caminho real" em breve.) +fst ("elm", 42) -- "elm" +snd ("elm", 42) -- 42 + +-- Uma tupla vazia ou "unidade" às vezes é utilizada como um placeholder. +-- É o único valor de seu tipo, também chamado de "Unit". +() + +-- Registros são como tuplas mas os campos possuem nomes. A ordem dos campos +-- não importa. Observe que os valores dos registros utilizam sinais de igual, +-- e não dois-pontos. +{ x = 3, y = 7 } + +-- Acesse um campo com um ponto e o nome do campo. +{ x = 3, y = 7 }.x -- 3 + +-- Ou com uma função acessora, que é um ponto e o nome do próprio campo. +.y { x = 3, y = 7 } -- 7 + +-- Atualiza os campos de um registro. (Ele já deve ter os campos.) +{ person | + name = "George" } + +-- Atualiza vários campos de uma só vez utilizando os valores atuais. +{ particle | + position = particle.position + particle.velocity, + velocity = particle.velocity + particle.acceleration } + +{-- Fluxo de Controle --} + +-- Declarações if sempre devem ter um else e os valores devem ser do mesmo tipo. +if powerLevel > 9000 then + "WHOA!" +else + "meh" + +-- Declarações if podem ser encadeadas. +if n < 0 then + "n é negativo" +else if n > 0 then + "n é positivo" +else + "n é zero" + +-- Utilize declarações case para casar padrões entre diferentes possibilidades. +case aList of + [] -> "casa com uma lista vazia" + [x]-> "casa com uma lista de exatamente um item, " ++ toString x + x::xs -> "casa com uma lista de pelo menos um item cuja cabeça é " ++ toString x +-- O casamento do padrão acontece na ordem. Se colocarmos [x] por último, ele +-- nunca iria casar porque x::xs também casa (xs seria a lista vazia). Os +-- casamentos não "falham". +-- O compilador irá alertá-lo sobre casos faltantes ou extras. + +-- Casa padrão com um Maybe. +case List.head aList of + Just x -> "A cabeça é " ++ toString x + Nothing -> "A lista estava vazia." + +{-- Funções --} + +-- A sintaxe do Elm é muito mínima, baseando-se principalmente em espaços em +-- branco em vez de parênteses e chaves. Não existe a palavra-chave "return". + +-- Define uma função com seu nome, argumentos, um sinal de igual e o corpo. +multiply a b = + a * b + +-- Aplica (chama) uma função passando seus argumentos (vírgulas não necessárias). +multiply 7 6 -- 42 + +-- Aplica parcialmente uma função passando somente alguns de seus argumentos. +-- Dando, em seguida, um novo nome a função. +double = + multiply 2 + +-- Constantes são semelhantes, exceto que não há argumentos. +answer = + 42 + +-- Passa funções como argumentos para outras funções. +List.map double [1..4] -- [2, 4, 6, 8] + +-- Ou escreva uma função anônima. +List.map (\a -> a * 2) [1..4] -- [2, 4, 6, 8] + +-- Você pode casar um padrão na definição de funções quando há somente um caso. +-- Esta função recebe uma tupla em vez de dois argumentos. +-- Esta é a maneira que você normalmente vai desempacotar/extrair valores de tuplas. +area (width, height) = + width * height + +area (6, 7) -- 42 + +-- Utilize chaves para casar o padrão de nomes de campos de um registro. +-- Utilize let para definir valores intermediários. +volume {width, height, depth} = + let + area = width * height + in + area * depth + +volume { width = 3, height = 2, depth = 7 } -- 42 + +-- Funções podem ser recursivas. +fib n = + if n < 2 then + 1 + else + fib (n - 1) + fib (n - 2) + +List.map fib [0..8] -- [1, 1, 2, 3, 5, 8, 13, 21, 34] + +-- Outra função recursiva (utilize List.length em um código de verdade). +listLength aList = + case aList of + [] -> 0 + x::xs -> 1 + listLength xs + +-- Chamadas de funções acontecem antes de qualquer operador infixo. +-- Os parênteses indicam a precendência. +cos (degrees 30) ^ 2 + sin (degrees 30) ^ 2 -- 1 +-- Primeiro degrees é aplicada em 30, então o resultado é passado para as +-- funções de trigonometria, que então é elevado ao quadrado e, por fim, a +-- adição acontece. + +{-- Tipos e Anotações de Tipos --} + +-- O compilador irá inferir o tipo de cada valor em seu programa. +-- Tipos iniciam com letra maiúscula. Leia x : T como "x é do tipo T". +-- Alguns tipos comuns que você pode ver no REPL do Elm. +5 : Int +6.7 : Float +"hello" : String +True : Bool + +-- Funções têm tipos também. Leia -> como "vai para". Pense no tipo mais à +-- direita como o tipo do valor de retorno e os outros como argumentos. +not : Bool -> Bool +round : Float -> Int + +-- Quando você define um valor, é uma boa prática escrever seu tipo acima dele. +-- A anotação é uma forma de documentação, que é verifica pelo compilador. +double : Int -> Int +double x = x * 2 + +-- Argumentos de uma função são passados entre parênteses. +-- Tipos com letra minúscula são tipos variáveis: eles podem ser de qualquer +-- tipo, desde que cada chamada seja consistente. +List.map : (a -> b) -> List a -> List b +-- "List.map é do tipo a-vai-para-b, vai para lista de a e vai para lista de b." + +-- Existem três tipos especiais com minúsculas: number, comparable e appendable. +-- Numbers permite que você utilize aritmética em Ints e Floats. +-- Comparable permite você ordenar números e strings, como a < b. +-- Appendable permite que coisas possam ser combinadas com a ++ b. + +{-- Type Aliases e Union Types --} + +-- Quando você escreve um registro ou uma tupla, seu tipo já existe. +-- (Observe que os tipos de um registro utilizam dois-pontos e os valores de um +-- registro utilizam igual.) +origin : { x : Float, y : Float, z : Float } +origin = + { x = 0, y = 0, z = 0 } + +-- Você pode dar um bom nome para tipos existentes com um type alias. +type alias Point3D = + { x : Float, y : Float, z : Float } + +-- Se você cria um alias para um registro, você pode usar o nome como uma +-- função construtora. +otherOrigin : Point3D +otherOrigin = + Point3D 0 0 0 + +-- Mas ele ainda é do mesmo tipo, então você pode compará-los. +origin == otherOrigin -- True + +-- Por outro lado, a definição de um union type cria um tipo que não existia +-- antes. Um union type é chamado assim porque ele pode ser uma de muitas +-- possibilidades. Cada uma das possibilidades é representada como uma "tag". +type Direction = + North | South | East | West + +-- As tags podem levar outros valores de tipos conhecidos. Isso pode trabalhar +-- recursivamente. +type IntTree = + Leaf | Node Int IntTree IntTree +-- "Leaf" e "Node" são as tags. Tudo após uma tag é um tipo. + +-- As tags podem ser usadas como valores ou funções. +root : IntTree +root = + Node 7 Leaf Leaf + +-- Union types (e type aliases) podem utilizar tipos variáveis. +type Tree a = + Leaf | Node a (Tree a) (Tree a) +-- "O tipo árvore-de-a é uma folha ou um nó de a, árvore-de-a e árvore-de-a." + +-- Casa padrão com union tags. As tags maiúsculas serão casadas de maneira exa- +-- ta. As variáveis minúsculas irão casar com qualquer coisa. Sublinhado também +-- casa com qualquer coisa, mas siginifica que você não o está utilizando. +leftmostElement : Tree a -> Maybe a +leftmostElement tree = + case tree of + Leaf -> Nothing + Node x Leaf _ -> Just x + Node _ subtree _ -> leftmostElement subtree + +-- Isso é praticamente a própria linguagem. Agora vamos ver como organizar e +-- executar seu código. + +{-- Módulos e Imports --} + +-- As bibliotecas internas são organizadas em módulos, assim como quaisquer +-- bibliotecas de terceiros que você possa utilizar. Para grandes projetos, +-- você pode definir seus próprios módulos. + +-- Coloque isso no topo do arquivo. Se for omitido, você está no Main. +module Name where + +-- Por padrão, tudo é exportado. Você pode especificar as exportações de forma +-- explícita. +module Name (MyType, myValue) where + +-- Um padrão comum é exportar um union type mas não suas tags. Isto é conhecido +-- como "tipo opaco" e é frequentemente utilizado em bibliotecas. + +-- Importe código de outros módulos para utilizá-lo no seu código. +-- Coloque Dict no escopo para você poder chamar Dict.insert. +import Dict + +-- Importe o módulo Dict e o tipo Dict para que suas anotações não tenham que +-- dizer Dict.Dict. Você ainda pode utilizar Dict.insert. +import Dict exposing (Dict) + +-- Renomeie um import. +import Graphics.Collage as C + +{-- Portas --} + +-- Uma porta indica que você estará se comunicando com o mundo exterior. +-- Portas são permitidas somente no módulo Main. + +-- Uma porta de entrada é apenas uma assinatura de tipo. +port clientID : Int + +-- Uma porta de saída tem uma definição. +port clientOrders : List String +port clientOrders = ["Books", "Groceries", "Furniture"] + +-- Não vamos entrar em detalhes, mas você configura callbacks no JavaScript +-- para enviar nas portas de entrada e receber nas portas de saída. + +{-- Ferramentas de Linha de Comando --} + +-- Compila um arquivo. +$ elm make MyFile.elm + +-- A primeira vez que você fizer isso, o Elm instalará as bibliotecas internas +-- e criará o elm-package.json, onde a informação sobre seu projeto é mantida. + +-- O reactor é um servidor que compila e roda seus arquivos. +-- Clique na chave ao lado dos nomes de arquivo para entrar no depurador de +-- viagem no tempo. +$ elm reactor + +-- Teste expressões simples no Read-Eval-Print Loop. +$ elm repl + +-- Pacotes são identificados pelo usuário e nome do repositório no GitHub. +-- Instale um novo pacote e registre-o no elm-package.json. +$ elm package install evancz/elm-html + +-- Veja o que mudou entre as versões de um pacote. +$ elm package diff evancz/elm-html 3.0.0 4.0.2 +-- O gerenciador de pacotes do Elm obriga o versionamento semântico, logo +-- mudanças de versões no minor nunca quebrará o seu build! +``` + +A linguagem Elm é supreendentemente pequena. Agora você pode olhar para quase +qualquer código-fonte em Elm e ter uma ideia aproximada do que está acontecendo. +No entanto, as possibilidades para código resistente a erros e de fácil +refatoração são infinitas! + +Aqui estão algumas referências utéis. + +* O [site do Elm](http://elm-lang.org/). Ele inclui: + * Links para os [instaladores](http://elm-lang.org/install) + * [Documentação](http://elm-lang.org/docs), incluindo [a referência de sintaxe](http://elm-lang.org/docs/syntax) + * Muitos [exemplos](http://elm-lang.org/examples) úteis + +* Documentação para as [bibliotecas internas do Elm](http://package.elm-lang.org/packages/elm-lang/core/latest/). Tome nota de: + * [Basics](http://package.elm-lang.org/packages/elm-lang/core/latest/Basics), que é importada por padrão + * [Maybe](http://package.elm-lang.org/packages/elm-lang/core/latest/Maybe) e seu primo [Result](http://package.elm-lang.org/packages/elm-lang/core/latest/Result), comumente utilizados para valores faltantes e manipulação de erros + * Estruturas de dados como [List](http://package.elm-lang.org/packages/elm-lang/core/latest/List), [Array](http://package.elm-lang.org/packages/elm-lang/core/latest/Array), [Dict](http://package.elm-lang.org/packages/elm-lang/core/latest/Dict) e [Set](http://package.elm-lang.org/packages/elm-lang/core/latest/Set) + * [Codificação](http://package.elm-lang.org/packages/elm-lang/core/latest/Json-Encode) e [decodificação](http://package.elm-lang.org/packages/elm-lang/core/latest/Json-Decode) JSON + +* [A Arquitetura Elm](https://github.com/evancz/elm-architecture-tutorial#the-elm-architecture). Uma dissertação pelo criador do Elm com exemplos sobre como organizar código em componentes. + +* A [lista de e-mail do Elm](https://groups.google.com/forum/#!forum/elm-discuss). Todos são amigáveis e solícitos. + +* [Escopo em Elm](https://github.com/elm-guides/elm-for-js/blob/master/Scope.md#scope-in-elm) e [Como Ler uma Anotação de Tipo](https://github.com/elm-guides/elm-for-js/blob/master/How%20to%20Read%20a%20Type%20Annotation.md#how-to-read-a-type-annotation). Mais sobre guias da comunidade sobre o básico de Elm escrito por desenvolvedores JavaScript. + +Saia e escreva algum código Elm! diff --git a/pt-br/git-pt.html.markdown b/pt-br/git-pt.html.markdown index 907892b1..e59ba901 100644 --- a/pt-br/git-pt.html.markdown +++ b/pt-br/git-pt.html.markdown @@ -2,7 +2,7 @@ category: tool tool: git lang: pt-br -filename: LearnGit.txt +filename: LearnGit-br.txt contributors: - ["Jake Prather", "http://github.com/JakeHP"] - ["Leo Rudberg" , "http://github.com/LOZORD"] diff --git a/pt-br/julia-pt.html.markdown b/pt-br/julia-pt.html.markdown new file mode 100644 index 00000000..48d97e58 --- /dev/null +++ b/pt-br/julia-pt.html.markdown @@ -0,0 +1,748 @@ +--- +language: Julia +filename: learnjulia-pt.jl +contributors: + - ["Leah Hanson", "http://leahhanson.us"] +translators: + - ["Davidson Mizael", "https://github.com/davidsonmizael"] +lang: pt-br +--- + +Julia é uma linguagem homoiconic funcional focada na computação tecnica. Ao mesmo tempo que ela tem todo o poder dos homoiconic macros, funções de primeira classe, e controle de baixo nivel, Julia é tão facil para aprender e usar quanto Python. + +Este tutorial é baseado no Julia 0.3. + +```ruby +# Linhas únicas de comentários começam com o simbolo hash(jogo da velha). +#= Comentários de multiplas linhas podem ser escritos + colocando '#=' antes do texto e '=#' + após o texto. Eles também podem ser agrupados +=# + +#################################################### +## 1. Tipos primitivos e operadores +#################################################### + +# Tudo em Julia é uma expressão. + +# Há muitos tipos básicos de numeros. +3 # => 3 (Int64) +3.2 # => 3.2 (Float64) +2 + 1im # => 2 + 1im (Complex{Int64}) +2//3 # => 2//3 (Rational{Int64}) + +# Todos os operadores inseguros normais estão disponiveis. +1 + 1 # => 2 +8 - 1 # => 7 +10 * 2 # => 20 +35 / 5 # => 7.0 +5 / 2 # => 2.5 # dividir um Int por um Int resulta em um float +div(5, 2) # => 2 # para um restultado truncado, use div +5 \ 35 # => 7.0 +2 ^ 2 # => 4 # elevado,não o opeardor binário xor +12 % 10 # => 2 + +# Impõe a priodidade nos parenteses +(1 + 3) * 2 # => 8 + +# Operadores binarios +~2 # => -3 # not +3 & 5 # => 1 # and +2 | 4 # => 6 # or +2 $ 4 # => 6 # xor +2 >>> 1 # => 1 # deslocamento lógico de bits a direita +2 >> 1 # => 1 # deslocamento aritmético de bits a direita +2 << 1 # => 4 # deslocamento lógico/aritmético de bits a esquerda + +# Você pode usar a função bits para ver a representação binária de um numero. +bits(12345) +# => "0000000000000000000000000000000000000000000000000011000000111001" +bits(12345.0) +# => "0100000011001000000111001000000000000000000000000000000000000000" + +# Valores booleanos são primitivos. +true +false + +# Operadores booleanos +!true # => false +!false # => true +1 == 1 # => true +2 == 1 # => false +1 != 1 # => false +2 != 1 # => true +1 < 10 # => true +1 > 10 # => false +2 <= 2 # => true +2 >= 2 # => true +# Comparações podem ser encadeadas +1 < 2 < 3 # => true +2 < 3 < 2 # => false + +# Strings são criadas com " +"Isso é uma String." + +# Caracteres literais são escritos com ' +'a' + +# Uma string pode ser indexada como um vetor de caracteres +"Isso é uma string"[1] # => 'I' # Julia começa a indexar a partir do 1 +# Porém isso não funcionará direito com strings em UTF8, +# portanto é recomendado usar iterações sobre uma string (map, loops com for, etc). + +# $ pode ser usado para interpolação de string: +"2 + 2 = $(2 + 2)" # => "2 + 2 = 4" +# Você pode usar qualquer expressão Julia dentro dos parenteses. + +# Outro jeito de formatar strings é com um macro no printf. +@printf "%d é menor que %f" 4.5 5.3 # 5 é menor que 5.300000 + +# Escrever na tela é fácil +println("Eu sou Julia. Prazer em conhece-lo!") + +#################################################### +## 2. Variáveis e coleções +#################################################### + +#Você não declara variáveis antes de atribui-lás. +some_var = 5 # => 5 +some_var # => 5 + +# Acessando a variável anterior não iniciada é um erro +try + some_other_var # => ERROR: some_other_var não definida +catch e + println(e) +end + +# Nomes de variáveis começam com uma letra. +# Depois disso, você pode usar letras, digitos, underscores e pontos de exclamação. +SomeOtherVar123! = 6 # => 6 + +# Você também pode usar caractéres unicode +☃ = 8 # => 8 +# Estes são especialmente reservados para notações matemáticas. +2 * π # => 6.283185307179586 + +# Uma nota na convenção de nomes em Julia: +# +# * A separação de palavras pode ser feita por underscores ('_'), mas o uso +# de underscore é desencorajado a menos que o nome da variável seja dificil +# de ler. +# +# * Os nomes de tipos começam com letra maiúscula e a separação de letras é +# feita a partir de CamelCase no lugar de underscores. +# +# * Nomes de funções e macros são em minúsculo, sem underscore. +# +# * Funções que modificam a própria entrada tem nomes que terminam em !. Estas +# funções são chamadas as vezes de funções de mutação ou função in-place. + +# Vetores armazenam uma sequencia de valores indexados por integer de 1 a n: +a = Int64[] # => 0-element Int64 Array + +# 1-Vetores dimensionais literais podem ter seus valores separados por virgula. +b = [4, 5, 6] # => 3-element Int64 Array: [4, 5, 6] +b[1] # => 4 +b[end] # => 6 + +# 2-Vetores dimensionais usam espaço para separar valores e ponto e virgula para linhas. +matrix = [1 2; 3 4] # => 2x2 Int64 Array: [1 2; 3 4] + +# Adiciona-se coisas ao final de uma lista com push! e append! +push!(a,1) # => [1] +push!(a,2) # => [1,2] +push!(a,4) # => [1,2,4] +push!(a,3) # => [1,2,4,3] +append!(a,b) # => [1,2,4,3,4,5,6] + +# Remove-se do final com pop! +pop!(b) # => 6 e 'b' agora é [4,5] + +# Vamos coloca-lo de novo +push!(b,6) # 'b' agora é [4,5,6] de novo. + +a[1] # => 1 # lembre-se que Julia indexa a partir de 1, não 0. + +# end é um atalho para a ultima posição. Pode ser usada em qualquer +# expressão indexada. +a[end] # => 6 + +# nós também temos shift e unshift +shift!(a) # => 1 e 'a' agora é [2,4,3,4,5,6] +unshift!(a,7) # => [7,2,4,3,4,5,6] + +# Funções que terminam com ponto de exclamação indicam que elas modificam +# seus argumentos. +arr = [5,4,6] # => 3-element Int64 Array: [5,4,6] +sort(arr) # => [4,5,6]; 'arr' continua [5,4,6] +sort!(arr) # => [4,5,6]; 'arr' agora é [4,5,6] + +# Olhar além dos limites é um BoundsError +try + a[0] # => ERROR: BoundsError() in getindex at array.jl:270 + a[end+1] # => ERROR: BoundsError() in getindex at array.jl:270 +catch e + println(e) +end + +# Erros listam a linha e o nome do arquivo que ele está, mesmo se for uma +# biblioteca padrão. Se você construiu Julia pelo source, você pode olhar na +# pasta base dentro da pasta do Julia para encontrar esses arquivos. + +# Você pode inicializar vetores com limites +a = [1:5;] # => 5-element Int64 Array: [1,2,3,4,5] + +# Você pode ver até um limite com a sintaxe separada +a[1:3] # => [1, 2, 3] +a[2:end] # => [2, 3, 4, 5] + +# Remova elementos de um array pelo index com splice! +arr = [3,4,5] +splice!(arr,2) # => 4 ; arr is now [3,5] + +# Concatene listas com append! +b = [1,2,3] +append!(a,b) # 'a' agora é [1, 2, 3, 4, 5, 1, 2, 3] + +# Cheque se um valor existe me uma lista com in +in(1, a) # => true + +# Veja o tamanho com lenght +length(a) # => 8 + +# Tuples não podem ser mudados. +tup = (1, 2, 3) # => (1,2,3) # um tuple (Int64,Int64,Int64). +tup[1] # => 1 +try: + tup[1] = 3 # => ERROR: não há metodo setindex!((Int64,Int64,Int64),Int64,Int64) +catch e + println(e) +end + +# Muitas litas de funções também trabalham com tuples +length(tup) # => 3 +tup[1:2] # => (1,2) +in(2, tup) # => true + +#Você pode desempacotar tuples para variáveis. +a, b, c = (1, 2, 3) # => (1,2,3) # 'a' agora é 1, 'b' agora é 2 e 'c' agora é 3 + +# Tuplas são criados mesmo se você deixar fora dos parenteses +d, e, f = 4, 5, 6 # => (4,5,6) + +# Uma tupla de um elemento é diferente do valor que ele contém +(1,) == 1 # => false +(1) == 1 # => true + +# Olhe como é facil pra trocar dois valores +e, d = d, e # => (5,4) # 'd' agora é 5 e 'e' agora é 4 + +# Dicionários armazenam mapeamentos +empty_dict = Dict() # => Dict{Any,Any}() + +# Você pode criar um dicionário usando um literal +filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3] +# => Dict{ASCIIString,Int64} + +# Veja os valores com [] +filled_dict["one"] # => 1 + +# Pegue todas as chaves +keys(filled_dict) +# => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) +# Nota - as chaves dos dicionários não são ordenadas nem estão na ordem que você as inseriu. + +# Pegue todos os valores +values(filled_dict) +# => ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) +# Nota - A mesma coisa que na nota acima sobre a ordenação das chaves. + +# Cheque pela existencia de chaves em um dicionário com in e haskey +in(("one", 1), filled_dict) # => true +in(("two", 3), filled_dict) # => false +haskey(filled_dict, "one") # => true +haskey(filled_dict, 1) # => false + +# Procurar por uma chave não existente irá gerar um erro +try + filled_dict["four"] # => ERROR: key not found: four in getindex at dict.jl:489 +catch e + println(e) +end + +# Use o método get para escapar desse erro passando um valor padrão +# get(dictionary,key,default_value) +get(filled_dict,"one",4) # => 1 +get(filled_dict,"four",4) # => 4 + +# Use sets para representar coleções de valores unicos e não ordenados +empty_set = Set() # => Set{Any}() +# Inicialize um set com valores +filled_set = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4) + +# Adicione mais valores para um set +push!(filled_set,5) # => Set{Int64}(5,4,2,3,1) + +# Cheque se um valor está no set +in(2, filled_set) # => true +in(10, filled_set) # => false + +# Não há funções para interseção de set, união e diferença. +other_set = Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3) +intersect(filled_set, other_set) # => Set{Int64}(3,4,5) +union(filled_set, other_set) # => Set{Int64}(1,2,3,4,5,6) +setdiff(Set(1,2,3,4),Set(2,3,5)) # => Set{Int64}(1,4) + +#################################################### +## 3. Controle de fluxo +#################################################### + +# Vamos fazer uma variável +some_var = 5 + +# Aqui está um if. Identação nao é importante em Julia. +if some_var > 10 + println("some_var é totalmente maior que 10.") +elseif some_var < 10 # Essa clausula elseif é opcional. + println("some_var é menor que 10.") +else # A clausula else é opcional também. + println("some_var é literalmente 10.") +end +# => exibe "some_var é menor que 10" + +# Loops for repetem sobre variaveis iteráveis. +# Tipos iterativos incluem Range, Array, set Dict e String. +for animal=["dog", "cat", "mouse"] + println("$animal is a mammal") + # Você pode interpolar variáveis usando $ ou expressões em strings +end +# exibe: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +# Você pode usar 'in' no lugar de '='. +for animal in ["dog", "cat", "mouse"] + println("$animal is a mammal") +end +# exibe: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +for a in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"] + println("$(a[1]) is a $(a[2])") +end +# exibe: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +for (k,v) in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"] + println("$k is a $v") +end +# exibe: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +# Loops while circulam enquanto a condição é true +x = 0 +while x < 4 + println(x) + x += 1 # Abreveação para x = x + 1 +end +# exibe: +# 0 +# 1 +# 2 +# 3 + +# Trate exceções com um bloco try/catch +try + error("help") +catch e + println("caught it $e") +end +# => caught it ErrorException("help") + + +#################################################### +## 4. Funções +#################################################### + +# A palavra chave 'function' cria novas funções +#function name(arglist) +# corpo... +#end +function add(x, y) + println("x is $x and y is $y") + + # Funções retornam o valor da sua ultima declaração +t x + y +end + +add(5, 6) # => 11 after printing out "x is 5 and y is 6" + +# Você pode definir funções que tomam um numero incerto de +# argumentos +function varargs(args...) + return args + # use a palavra chave return para retornar um valor em qualquer parte da função +end +# => varargs (generic function with 1 method) + +varargs(1,2,3) # => (1,2,3) + +# O ... é chamado de splat. +# Nós apenas o usamos na definição de uma função. +# Também pode ser usado na chamada de uma função, +# onde ela vai abrir um Array ou o conteúdo de um Tuple na lista de argumentos. +Set([1,2,3]) # => Set{Array{Int64,1}}([1,2,3]) # produz um Set de Arrays +Set([1,2,3]...) # => Set{Int64}(1,2,3) # isso é equivalente a Set(1,2,3) + +x = (1,2,3) # => (1,2,3) +Set(x) # => Set{(Int64,Int64,Int64)}((1,2,3)) # um Set de Tuples +Set(x...) # => Set{Int64}(2,3,1) + +# Você pode definir funções com argumentos posicionais opcionais. +function defaults(a,b,x=5,y=6) + return "$a $b and $x $y" +end + +defaults('h','g') # => "h g and 5 6" +defaults('h','g','j') # => "h g and j 6" +defaults('h','g','j','k') # => "h g and j k" +try + defaults('h') # => ERROR: no method defaults(Char,) + defaults() # => ERROR: no methods defaults() +catch e + println(e) +end + +# Você pode definir funções que tomam argumentos como palavras chaves +function keyword_args(;k1=4,name2="hello") # note the ; + return ["k1"=>k1,"name2"=>name2] +end + +keyword_args(name2="ness") # => ["name2"=>"ness","k1"=>4] +keyword_args(k1="mine") # => ["k1"=>"mine","name2"=>"hello"] +keyword_args() # => ["name2"=>"hello","k1"=>4] + +# Você pode combinar todos os tipos de argumentos em uma só função +function all_the_args(normal_arg, optional_positional_arg=2; keyword_arg="foo") + println("normal arg: $normal_arg") + println("optional arg: $optional_positional_arg") + println("keyword arg: $keyword_arg") +end + +all_the_args(1, 3, keyword_arg=4) +# exibe: +# normal arg: 1 +# optional arg: 3 +# keyword arg: 4 + +# Julia tem funções de primeira classe +function create_adder(x) + adder = function (y) + return x + y + end + return adder +end + +# Isso é "sintexe furiosa de lambda" pra criar funções anônimas. +(x -> x > 2)(3) # => true + +#Esta função é identica a implementação da create_adder acima. +function create_adder(x) + y -> x + y +end + +# Você também pode nomear funções internas, se você quiser +function create_adder(x) + function adder(y) + x + y + end + adder +end + +add_10 = create_adder(10) +add_10(3) # => 13 + + +# Há +# There are built-in higher order functions +map(add_10, [1,2,3]) # => [11, 12, 13] +filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7] + +# Nós podemos usar listas de compreensão para melhores mapeamentos +[add_10(i) for i=[1, 2, 3]] # => [11, 12, 13] +[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13] + +#################################################### +## 5. Tipos +#################################################### + +#Julia tem um sistema de tipos. +# Todo valor tem um tipo. Variaveis não tem tipos próprios. +# Você pode usar a função 'typeof' para pegar o valor. +typeof(5) # => Int64 + +# Tipos são valores de primeira classe. +typeof(Int64) # => DataType +typeof(DataType) # => DataType +# DataType é o tipo que representa tipos, incluindo ele mesmo. + +# Tipos são usados para documentação, optimização e envio +# Eles não são estaticamente checados. + +# Usuários podem definir tipos +# Eles são como records ou structs em outras linguagens. +# Novos tipos são definidos usando a palavra chave 'type' + +# type Name +# field::OptionalType +# ... +# end +type Tiger + taillength::Float64 + coatcolor # não incluindo uma notação type é o mesmo que '::Any' +end + +# Os argumentos padrões de um construtor são as propriedades +# do tipo na ordem que eles são listados na definição. +tigger = Tiger(3.5,"orange") # => Tiger(3.5,"orange") + +# O tipo double como construtor de função para valores desse tipo +# The type doubles as the constructor function for values of that type +sherekhan = typeof(tigger)(5.6,"fire") # => Tiger(5.6,"fire") + +# Esses tipos no estilo struct são chamados tipos concretos +# Eles podem ser instanciados, mas não podem ter subtipos. +# O outro tipo de tipos são os tipos abstratos. + +# abstract Name +abstract Cat # apenas um nome e um ponto na hierarquia de tipo + +# Tipos abstratos podem ser instanciados, mas não podem ter subtipos. +# Por exemplo, Number é um tipo abstrato +subtypes(Number) # => 6-element Array{Any,1}: + # Complex{Float16} + # Complex{Float32} + # Complex{Float64} + # Complex{T<:Real} + # ImaginaryUnit + # Real +subtypes(Cat) # => 0-element Array{Any,1} + +# Todo tipo tem um super tipo; use a função 'super' para pegá-lo. +typeof(5) # => Int64 +super(Int64) # => Signed +super(Signed) # => Real +super(Real) # => Number +super(Number) # => Any +super(super(Signed)) # => Number +super(Any) # => Any +# Todos esss tipos, exceto o Int64, são abstratos. + +# <: é o operador de subtipagem +type Lion <: Cat # Lion é um subtipo de Cat + mane_color + roar::String +end + +# Você pode definir mais construtores para seu tipo +# É só definir uma função com o mesmo nome do tipo +# e chamar um construtor existente para pegar o valor do tipo correto +Lion(roar::String) = Lion("green",roar) +# Isso é um construtor externo porque ele está fora da definição do tipo + +type Panther <: Cat # Panther também é um subtipo de Cat + eye_color + Panther() = new("green") +# Panthers terão apenas esse construtor, e não construtor padrão. +end +# Usando construtores internos, como Panther faz, lhe da o controle +# sobre como os valores dos tipos são criados. +# Quando possivel, você deve usar construtores externos mais do que internos. + +#################################################### +## 6. Multiple-Dispatch +#################################################### + + +# Em Julia todas as funções nomeadas são funções genericas +# Isso significa que elas são construidas de muitos métodos pequenos +# Cada construtor para Lion é um metodo da função genérica Lion.Lion. + +# Para um exemplo sem construtor, vamos fazer a função meow + +# Definição para Lion, Panther e Tiger +function meow(animal::Lion) + animal.roar #propriedades do tipo de acesso usando a notação ponto '.' +end + +function meow(animal::Panther) + "grrr" +end + +function meow(animal::Tiger) + "rawwwr" +end + +# Testando a função meow +meow(tigger) # => "rawwr" +meow(Lion("brown","ROAAR")) # => "ROAAR" +meow(Panther()) # => "grrr" + +# Revendo o tipo local de hierarchy +issubtype(Tiger,Cat) # => false +issubtype(Lion,Cat) # => true +issubtype(Panther,Cat) # => true + +# Definindo uma função que recebe Cats +function pet_cat(cat::Cat) + println("The cat says $(meow(cat))") +end + +pet_cat(Lion("42")) # => exibe "The cat says 42" +try + pet_cat(tigger) # => ERROR: no method pet_cat(Tiger,) +catch e + println(e) +end + +# Em linguagens orientadas a objeto, envio unico é comúm +# isso significa que o método é selecionado baseado no tipo do seu primeiro argumento +# Em Julia todos os tipos de argumentos contribuem na seleção do melhor método + + +# Vamos definir uma função com mais argumentos, então poderemos ver a diferença +function fight(t::Tiger,c::Cat) + println("The $(t.coatcolor) tiger wins!") +end +# => fight (generic function with 1 method) + +fight(tigger,Panther()) # => exibe The orange tiger wins! +fight(tigger,Lion("ROAR")) # => exibir The orange tiger wins! + +# Vamos mudar o comportamento quando o gato é especificamente um leão +fight(t::Tiger,l::Lion) = println("The $(l.mane_color)-maned lion wins!") +# => fight (generic function with 2 methods) + +fight(tigger,Panther()) # => exobe The orange tiger wins! +fight(tigger,Lion("ROAR")) # => exobe The green-maned lion wins! + +# Nós não precisamos de um tigre para brigar +fight(l::Lion,c::Cat) = println("The victorious cat says $(meow(c))") +# => fight (generic function with 3 methods) + +fight(Lion("balooga!"),Panther()) # => exibe The victorious cat says grrr +try + fight(Panther(),Lion("RAWR")) # => ERROR: no method fight(Panther,Lion) +catch +end + +# Aliás, vamos deixar o gato ir primeiro +fight(c::Cat,l::Lion) = println("The cat beats the Lion") +# => Warning: New definition +# fight(Cat,Lion) at none:1 +# is ambiguous with +# fight(Lion,Cat) at none:2. +# Make sure +# fight(Lion,Lion) +# is defined first. +#fight (generic function with 4 methods) + +# Este aviso é porque não está claro qual método fight será chamado em: +fight(Lion("RAR"),Lion("brown","rarrr")) # => exibe The victorious cat says rarrr +# O resultado pode ser diferente em outras versões de Julia + +fight(l::Lion,l2::Lion) = println("The lions come to a tie") +fight(Lion("RAR"),Lion("brown","rarrr")) # => exibe The lions come to a tie + + +# Embaixo dos panos +# Você pode olhar o llvm e o código assembly gerado. + +square_area(l) = l * l # square_area (generic function with 1 method) + +square_area(5) #25 + +# O que acontece quando alimentamos square_area com um inteiro? +# What happens when we feed square_area an integer? +code_native(square_area, (Int32,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 # Prólogo + # push RBP + # mov RBP, RSP + # Source line: 1 + # movsxd RAX, EDI # Busca l na memoria? + # imul RAX, RAX # Faz o quadrado de l e armazena o resultado em RAX + # pop RBP # Restaura o ponteiro de base antigo + # ret # O resultado continua em RAX + +code_native(square_area, (Float32,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # Source line: 1 + # vmulss XMM0, XMM0, XMM0 # Múltiplicação escalar unica de precisão (AVX) + # pop RBP + # ret + +code_native(square_area, (Float64,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # Source line: 1 + # vmulsd XMM0, XMM0, XMM0 # Duplicação ecalar de precisão multipla(AVX) + # pop RBP + # ret + # +# Note que Julia usará instruções de ponto flutuante se quaser um dos +# argumentos forem float +# Vamos calcular a área de um circulo +circle_area(r) = pi * r * r # circle_area (generic function with 1 method) +circle_area(5) # 78.53981633974483 + +code_native(circle_area, (Int32,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # Source line: 1 + # vcvtsi2sd XMM0, XMM0, EDI # Carrega inteiro (r) da memória + # movabs RAX, 4593140240 # Carrega pi + # vmulsd XMM1, XMM0, QWORD PTR [RAX] # pi * r + # vmulsd XMM0, XMM0, XMM1 # (pi * r) * r + # pop RBP + # ret + # + +code_native(circle_area, (Float64,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # movabs RAX, 4593140496 + # Source line: 1 + # vmulsd XMM1, XMM0, QWORD PTR [RAX] + # vmulsd XMM0, XMM1, XMM0 + # pop RBP + # ret + # +``` + +## Extras + +Você pode ver mais um monte de detalhes no [manual de Julia] (http://docs.julialang.org/en/latest/manual/) +O melhor lugar pra pedir ajuda em Julia é a (muito amigável) [mailing list](https://groups.google.com/forum/#!forum/julia-users). diff --git a/pt-br/python3-pt.html.markdown b/pt-br/python3-pt.html.markdown index c5a3c020..9b6bd1b6 100644 --- a/pt-br/python3-pt.html.markdown +++ b/pt-br/python3-pt.html.markdown @@ -7,7 +7,7 @@ contributors: - ["Zachary Ferguson", "http://github.com/zfergus2"] translators: - ["Paulo Henrique Rodrigues Pinheiro", "http://www.sysincloud.it"] -language: pt-br +lang: pt-br filename: learnpython3-pt.py --- diff --git a/pt-br/self-pt.html.markdown b/pt-br/self-pt.html.markdown new file mode 100644 index 00000000..2fb2953b --- /dev/null +++ b/pt-br/self-pt.html.markdown @@ -0,0 +1,165 @@ +--- +language: self +contributors: + - ["Russell Allen", "http://github.com/russellallen"] +translators: + - ["Ricardo de Almeida Gonzaga", "http://github.com/ricardotk"] +lang: pt-br +filename: learnself-br.self +--- + +Self é um protótipo rápido baseado em linguagem orientada a objeto a qual roda em sua própria JIT vm. A maior parte do desenvolvimento é feito através de interações com objetos ativos, através de um ambiente visual de desenvolvimento chamado *morphic* com navegador e depurador integrados. + +Tudo em Self é um objeto. Toda computação é feita através do envio de mensagens para objetos. Objetos em Self podem ser compreendidos como conjuntos de slots de chave-valor. + +# Construindo objetos + +O analisador interno de Self pode construir objetos, incluindo objetos método. + +``` +"Isto é um comentario" + +"A string:" +'Isto é uma string com caracteres \'escapados\'.\n' + +"Um inteiro de 30 bits" +23 + +"Um float de 30 bits" +3.2 + +"-20" +-14r16 + +"Um objeto o qual entende apenas uma menssagem, 'x' que retorna 20" +(| + x = 20. +|) + +"Um objeto o qual tambem entende 'x', que atribui o slot x" +(| + x <- 20. +|) + +"Um objeto o qual entende o método 'doubleX' que +dobra o valor de x e então retorna o objeto" +(| + x <- 20. + doubleX = (x: x * 2. self) +|) + +"Um objeto o qual entende todas as mensagens +que 'traits point' entende". O analisador +procura 'traits point' enviando as mensagens +'traits' e 'point' para um objeto conhecido +chamado de 'lobby'. Ele procura pelo objeto +'true' também enviando a mensagem 'true' +para o 'lobby'."" +(| parent* = traits point. + x = 7. + y <- 5. + isNice = true. +|) +``` + +# Enviando mensagens para objetos + +Mensagens podem ser unárias, binárias ou palavras-chave. Precedência é nesta ordem. Diferentemente de Smalltalk, a precedência de mensagens binárias precisam ser especificadas, e todas as palavras-chave após a primeira devem começar com letra maiúscula. Mensagens são separadas de seu destinatário através de espaço em branco. + +``` +"mensagem unária, envia 'printLine' para o objeto '23' +o qual escreve a string '23' para stdout e retorna o objeto recebido (ie 23)" +23 printLine + +"envia a mensagem '+' com '7' para '23', em seguida a mensagem '*' com '8' para o resultado" +(23 + 7) * 8 + +"envia 'power:' para '2' com '8' retorna 256" +2 power: 8 + +"envia 'keyOf:IfAbsent:' para 'hello' com argumentos 'e' e '-1'. +Retorna 1, o índice de 'e' em 'hello'." +'hello' keyOf: 'e' IfAbsent: -1 +``` + +# Blocos + +Self define controle de fluxo assim como Smalltalk e Ruby por meio de blocos. Blocos são computações atrasadas da forma: + +``` +[|:x. localVar| x doSomething with: localVar] +``` + +Exemplos do uso de um bloco: + +``` +"retorna 'HELLO'" +'hello' copyMutable mapBy: [|:c| c capitalize] + +"retorna 'Nah'" +'hello' size > 5 ifTrue: ['Yay'] False: ['Nah'] + +"retorna 'HaLLO'" +'hello' copyMutable mapBy: [|:c| + c = 'e' ifTrue: [c capitalize] + False: ['a']] +``` + +Múltiplas expressões são separadas por ponto final. ^ retorna imediatamente. + +``` +"retorna An 'E'! How icky!" +'hello' copyMutable mapBy: [|:c. tmp <- ''| + tmp: c capitalize. + tmp = 'E' ifTrue: [^ 'An \'E\'! How icky!']. + c capitalize + ] +``` + +Blocos são realizados (completados) ao enviá-los a mensagem 'value' e herdando (imcumbir a) seus contextos: +``` +"retorna 0" +[|x| + x: 15. + "Repetidamente envia 'value' para o primeiro bloco enquanto o resultado do + envio de 'value' para o segundo bloco é o objeto 'true'" + [x > 0] whileTrue: [x: x - 1]. + x +] value +``` + +# Métodos + +Métodos são como blocos, porém eles não estão dentro de um contexto, ao invés disto são armazenados como valores de slots. Diferentemente de Smalltalk, métodos por padrão retornam o seu valor final e não 'self'. + +``` +"Aqui está um objeto com um slot atribuível 'x' e um método 'reduceXTo: y'. +Enviar a mensagem 'reduceXTo: 10' para este objeto colocará +o objeto '10' no slot 'x' e retornará o objeto original" +(| + x <- 50. + reduceXTo: y = ( + [x > y] whileTrue: [x: x - 1]. + self) +|) +. +``` + +# Protótipos + +Não existem classes em Self. A maneira de obter um objeto é encontrar um protótipo e copia-lo. + +``` +| d | +d: dictionary copy. +d at: 'hello' Put: 23 + 8. +d at: 'goodbye' Put: 'No!. +"Imprime No!" +( d at: 'goodbye' IfAbsent: 'Yes! ) printLine. +"Imprime 31" +( d at: 'hello' IfAbsent: -1 ) printLine. +``` + +# Informações adicionais + +O [Manual do Self](http://handbook.selflanguage.org) tem muito mais informações, e nada melhor do que por a mão na massa com Self através de sua [homepage](http://www.selflanguage.org). diff --git a/pt-br/swift-pt.html.markdown b/pt-br/swift-pt.html.markdown index e840b8cf..4ad67a06 100644 --- a/pt-br/swift-pt.html.markdown +++ b/pt-br/swift-pt.html.markdown @@ -353,7 +353,7 @@ internal class Rect: Shape { func shrink() { if sideLength > 0 { - --sideLength + sideLength -= 1 } } diff --git a/pt-br/vim-pt.html.markdown b/pt-br/vim-pt.html.markdown new file mode 100644 index 00000000..4f70079a --- /dev/null +++ b/pt-br/vim-pt.html.markdown @@ -0,0 +1,239 @@ +--- +category: tool +tool: vim +contributors: + - ["RadhikaG", "https://github.com/RadhikaG"] +translators: + - ["David Lima", "https://github.com/davelima"] +lang: pt-br +filename: LearnVim-pt.txt +--- + + +[Vim](www.vim.org) +(Vi IMproved - Vi Melhorado) é um clone do editor vi para Unix. Ele é um +editor de texto projetado para ter velocidade e produtividade, e está presente +na maioria dos systemas UNIX. O editor tem um grande número de atalhos de teclado +para agilizar a navegação para pontos específicos no arquivo, além de edição rápida. + +## Navegação do Vim: o básico + +``` + vim <nome-do-arquivo> # Abre <nome-do-arquivo> no vim + :q # Fecha o vim + :w # Salva o arquivo atual + :wq # Salva o arquivo e fecha o vim + :q! # Fecha o vim e descarta as alterações no arquivo + # ! *força* :q a executar, fechando o vim sem salvar antes + :x # Salvar o arquivo e fechao vim (atalho para :wq) + + u # Desfazer + CTRL+R # Refazer + + h # Move o cursor para a esquerda + j # Move o cursor para baixo + k # Move o cursor para cima + l # Move o cursor para a direita + + # Movendo o cursor dentro da linha + + 0 # Move para o início da linha + $ # Move para o final da linha + ^ # Move para o primeiro caractere da linha (ignora caracteres em branco) + + # Pesquisa no texto + + /palavra # Destaca todas as ocorrências de 'palavra' após o cursor + ?palavra # Destaca todas as ocorrências de 'palavra' antes do cursor + n # Move o cursor para a próxima ocorrência após a pesquisa + N # Move o cursor para a ocorrência anterior após a pesquisa + + :%s/foo/bar/g # Substitui 'foo' por 'bar' no arquivo inteiro + :s/foo/bar/g # Substitui 'foo' por 'bar' na linha atual + + # Pulando para caracteres específicos + + f<caracter> # Posiciona o cursor no próximo <caracter> + t<character> # Posiciona o cursor antes do próximo <caracter> + + # Por exemplo, + f< # Posiciona o cursor no < + t< # Posiciona o cursor logo antes do < + + # Movendo por palavras + + w # Move o cursor uma palavra a diante + b # Move o cursor uma palavra atrás + e # Move o cursor ao fim da palavra atual + + # Outros caracteres para mover o cursor no arquivo + + gg # Move para o topo do arquivo + G # Move para o final do arquivo + :NUM # Move para a linha NUM (NUM é qualquer número) + H # Move para o topo da tela visível + M # Move para o meio da tela visível + L # Move para o final da tela visível +``` + +## Modos: + +O Vim é baseado no conceito de **modos**. + +Modo Comando - usado para navegar e escrever comandos - o Vim já inicia nesse modo +Modo Inserção - usado para fazer alterações no arquivo +Modo Visual - usado para destacar textos e executar comandos neles +Modo Ex - usado para ir a linha com ':' no final da tela para executar comandos + +``` + i # Coloca o Vim no Modo Inserção, logo antes do cursor + a # Coloca o Vim no Modo Inserção, logo após o cursor + v # Coloca o Vim no Modo Visual + : # Coloca o Vim no Modo Ex + <esc> # Sai de qualquer modo que você estiver, e coloca o Vim no Modo Comando + + # Copiando e colando texto + + y # Coloca a seleção atual na área de transferência + yy # Coloca a linha atual na área de transferência + d # Deleta a seleção tual + dd # Deleta a linha atual + p # Cola o texto copiado após a posição do cursor + P # Cola o texto copiado antes da posição do cursor + x # Deleta o caractere que está na posição do cursor +``` + +## A 'Gramática' do Vim + +Podemos pensar no Vim como uma série de comendos +em um formato 'Verbo-Modificador-Nome', onde: + +Verbo - sua ação +Modificador - como você executará sua ação +Nome - o objeto onde você vai executar sua acão + +Alguns exemplos importantes de 'Verbos', 'Modificadores' e 'Nomes': + +``` + # 'Verbos' + + d # Apagar (Delete) + c # Alterar (Change) + y # Copiar (Yank) + v # Seleção Visual + + # 'Modificadores' + + i # Dentro (Inside) + a # Em torno de (Around) + NUM # Número (NUM qualquer número) + f # Pesquisa algo e posiciona o cursor acima do resultado + t # Pesquisa algo e posiciona o cursor logo antes do resultado + / # Encontra algo a frente do cursor + ? # Encontra algo antes do cursor + + # 'Nomes' + + w # Palavra (word) + s # Sentência + p # Parágrafo + b # Bloco + + # Exemplos de comandos + + d2w # Apaga 2 palavras + cis # Altera dentro de uma sentência + yip # Coloca o parágrafo atual da área de transferência) + ct< # Altera para '<' + # Altera todo o texto a partir da posição do cursor até o próximo '<' + d$ # Apaga tudo da posição do cursor até o final da linha +``` + +## Alguns atalhos e dicas + + <!--TODO: Adicionar mais!--> +``` + > # Adiciona um bloco de indentação + < # Remove um bloco de indentação + :earlier 15m # Reverte o documento para como ele estava há 15 minutos atrás + :later 15m # Reverte o comando acima + ddp # Troca linhas consecutivas de posição, dd e depois p + . # Repete a última ação +``` + +## Macros + +Macros, basicamente, são ações graváveis. +Quando você começa a gravar uma macro, ele salva **toda** ação e comando +que você usar, até que você pare de gravar. Ao executar uma macro, ele aplica +exatamente a mesma sequencia de ações e comandos na seleção atual. + +``` + qa # Inicia a gravação de uma macro chamado 'a' + q # Para a gravação + @a # Executa a macro +``` + +### Configurando o ~/.vimrc + +O arquivo .vimrc pode ser usado para configurar o Vim no seu início. + +Exemplo de arquivo ~/.vimrc + +``` +" Exemplo de ~/.vimrc +" 2015.10 + +" Obrigatório para rodar apenas no Vim (Vi Improved) +set nocompatible + +" Determina o tipo de arquivo pelo nome para habilitar indentação automática, etc +filetype indent plugin on + +" Habilita sintaxe colorida +syntax on + +" Ativa um 'auto-completar' melhor para a linha de comando +set wildmenu + +" Faz as buscas não diferenciarem maiúsculas-minúsculas (case insensitive) +" Exceto quando você usar letras maiúsculas +set ignorecase +set smartcase + +" Quando criar uma nova linha e a indentação por tipo de arquivo estiver +" desabilitada, mantem a mesma indentação da linha atual +set autoindent + +" Mostra o número das linhas à esquerda +set number + +" Opções de indentação, aqui você pode mudar como preferir + +" Número de espaços visíveis por TAB +set tabstop=4 + +" Número de espaços por TAB ao editar um arquivo +set softtabstop=4 + +" Número de espaços usados nas funções de indentação (>> e <<) +set shiftwidth=4 + +" Converte TABs em espaços +set expandtab + +" Habilita indentação/alinhamento inteligente +set smarttab +``` + +### Referências + +[Vim | Home](http://www.vim.org/index.php) (EN) + +`$ vimtutor pt` + +[Vim: um tutorial/cartilha](https://danielmiessler.com/study/vim/) (EN) + +[O que são as partes sombrias do Vim que sua mãe nunca te explicou? (tópico no Stack Overflow)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about) (EN) + +[Arch Linux Wiki](https://wiki.archlinux.org/index.php/Vim) (EN) |