├── .gitignore
├── README.md
├── Super Sayajin I
├── Modulo 01
│ ├── README.md
│ ├── aula01.md
│ ├── aula01
│ │ ├── README.md
│ │ └── src
│ │ │ ├── add.subtract.js
│ │ │ ├── deny.js
│ │ │ ├── exponenciacao.js
│ │ │ ├── exponenciacao.simples.js
│ │ │ ├── isParisImpar.js
│ │ │ ├── media.while.js
│ │ │ ├── multiply.js
│ │ │ ├── percent.while.js
│ │ │ ├── radiciacao.js
│ │ │ ├── raizes.js
│ │ │ ├── soma.negativo.js
│ │ │ ├── sum.while.js
│ │ │ ├── times.oozaru.const.js
│ │ │ ├── times.oozaru.js
│ │ │ ├── times.reusable.js
│ │ │ ├── times.with.sum.js
│ │ │ └── times01.js
│ └── aula02
│ │ └── README.md
└── README.md
└── img
├── cards.jpg
├── ss1.jpg
├── ss2.jpg
├── ss3.jpg
├── ss4.jpg
└── ss5.jpg
/.gitignore:
--------------------------------------------------------------------------------
1 | # Logs
2 | logs
3 | *.log
4 | npm-debug.log*
5 | yarn-debug.log*
6 | yarn-error.log*
7 |
8 | .DS*
9 | */.DS*
10 |
11 | # Runtime data
12 | pids
13 | *.pid
14 | *.seed
15 | *.pid.lock
16 |
17 | # Directory for instrumented libs generated by jscoverage/JSCover
18 | lib-cov
19 |
20 | # Coverage directory used by tools like istanbul
21 | coverage
22 |
23 | # nyc test coverage
24 | .nyc_output
25 |
26 | # Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
27 | .grunt
28 |
29 | # Bower dependency directory (https://bower.io/)
30 | bower_components
31 |
32 | # node-waf configuration
33 | .lock-wscript
34 |
35 | # Compiled binary addons (http://nodejs.org/api/addons.html)
36 | build/Release
37 |
38 | # Dependency directories
39 | node_modules/
40 | jspm_packages/
41 |
42 | # Typescript v1 declaration files
43 | typings/
44 |
45 | # Optional npm cache directory
46 | .npm
47 |
48 | # Optional eslint cache
49 | .eslintcache
50 |
51 | # Optional REPL history
52 | .node_repl_history
53 |
54 | # Output of 'npm pack'
55 | *.tgz
56 |
57 | # Yarn Integrity file
58 | .yarn-integrity
59 |
60 | # dotenv environment variables file
61 | .env
62 |
63 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | 
2 |
3 |
4 | # Curso - JavaScript Super Saiyajin
5 |
6 | *depois de criar que percebi que faltou um i em Saiyajin*
7 |
8 | > **Curso COMPLETO de JavaScript do básico ao avançado trilhando o caminho Funcional com ES6.**
9 |
10 | *ps: ensinarei tudo que eu sei e ainda vou estudar sobre ES6/ES7*
11 |
12 | ## ES6
13 |
14 | Essa é uma pequena lista das *features* que o ES6 nos provê, ainda não
15 | domino todos os itens, mas com o decorrer de cada aula estudarei cada vez
16 | mais e mais para poder **passar o melhor conteúdo possível para você!**
17 |
18 | Separei pelos módulos onde cada uma será destrinchada:
19 |
20 | - [arrows](): Nível I - Módulo 1
21 | - [template strings](): Nível I - Módulo 1
22 | - [destructuring](): Nível I - Módulo 1
23 | - [default + rest + spread](): Nível I - Módulo 1
24 | - [let + const](): Nível I - Módulo 1
25 | - [array API](): Nível I - Módulo 1
26 | - [set + weakset](): Nível I - Módulo 1
27 | - [map + weakmap](): Nível I - Módulo 2
28 | - [number](): Nível I - Módulo 1
29 | - [math](): Nível I - Módulo 2
30 | - [string API](): Nível I - Módulo 2
31 | - [object APIs](): Nível I - Módulo 2
32 | - [symbols](): Nível I - Módulo 2
33 | - [enhanced object literals](): Nível I - Módulo 3
34 | - [classes](): Nível I: Módulo 3
35 | - [iterators + for..of](): Nível I - Módulo 3
36 | - [proxies](): Nível I - Módulo 3
37 | - [unicode](): Nível I - Módulo 4
38 | - [modules](): Nível I - Módulo 4
39 | - [module loaders](): Nível I - Módulo 4
40 | - [subclassable built-ins](): Nível I - Módulo 4
41 | - [generators](): Nível I - Módulo 4
42 | - [promises](): Nível I - Módulo 4
43 | - [binary and octal literals](): Nível I - Módulo 4
44 | - [reflect api](): Nível I - Módulo 4
45 | - [tail calls](): Nível I - Módulo 4
46 |
47 | *fonte: lista retirada de [https://github.com/lukehoban/es6features](https://github.com/lukehoban/es6features)*
48 |
49 |
50 | 
51 |
52 |
53 | ## Exercícios
54 |
55 | Para responder os exercícios crie um repositório chamado:
56 |
57 | `Curso-JavaScript-Super-Sayajin-Nível-1-Módulo-1-exercícios`
58 |
59 | Dentro dele crie uma pasta chamada aula01 ou aula02 ou aulaNumeroDela e coloque
60 | dentro todos seus códigos, sendo cada exercício separado por arquivo `.js`!
61 |
62 | **POR FAVOR teste seu código com Node.js ANTES DE ENVIAR!**
63 |
64 | Depois crie aqui nesse repositório uma ISSUE com o título sendo seu apelido aqui no
65 | Github e dentro dela coloque o link do seu repositório ou dos seus [gists](https://gist.github.com/).
66 |
67 |
68 | ## Pré-requisitos
69 |
70 | - Usar o cérebro
71 | - Ensino Médio
72 | - Ter [brio](https://www.youtube.com/watch?v=dpn1JL15AXA)
73 | - Ter Internet
74 |
75 |
76 |
77 |
78 | ## Antes do Curso
79 |
80 | 
81 |
82 | ## Depois do Curso
83 |
84 | 
85 |
86 | ## O Curso
87 |
88 | Esse curso, por mais que você odeie, irá iniciar pela Matemática mais básica possível,
89 | pois EU acredito que a Matemática Discreta é OBRIGATÓRIA para todo o programador, assim como é:
90 |
91 | - algoritmo
92 | - lógica ( booleana e matemática )
93 | - estrutura de dados
94 | - inglês
95 |
96 |
97 | > **Para você conseguir programar QUALQUER COISA, você no mínimo, precisa saber os itens acima.**
98 |
99 |
100 | > **Sabe o por quê?**
101 |
102 | > Simplesmente porque é com essa Matemática que você aprende os conceitos de função e conjuntos, que
103 | para mim é muitíssimo importante, pois antecede a própria Estrutura de Dados.
104 |
105 |
106 |
107 | Além disso veja a definição de uma função:
108 |
109 | > Uma função ou aplicação é uma relação de um conjunto A com um conjunto B.
110 |
111 | *fonte: [https://pt.wikipedia.org/wiki/Fun%C3%A7%C3%A3o_(matem%C3%A1tica)](https://pt.wikipedia.org/wiki/Fun%C3%A7%C3%A3o_(matem%C3%A1tica))*
112 |
113 |
114 | Trocando em míudos:
115 |
116 |
117 | > Uma função é a ação de transformação entre conjuntos, onde você SEMPRE
118 | terá dois conjuntos: de entrada e de saída. Ou seja, qualquer tipo de transformação
119 | que você faça será uma função que SEMPRE retornará algo.
120 |
121 |
122 | *ps1: se não retorna algo não é função*
123 |
124 | *ps2: em uma função de `set` você pode retornar o próprio objeto*
125 | *que contém a propriedade setada, para que você possa encadear suas funções,*
126 | *por exemplo.*
127 |
128 |
129 |
130 |
131 |
132 | ## Níveis
133 |
134 | 
135 |
136 | - **Super Sayajin I**
137 | - **Super Sayajin II**
138 | - **Super Sayajin III**
139 | - **Super Sayajin IV**
140 | - **Super Sayajin V**
141 |
142 | Antes de falar da ementa de cada um eu quero que você entenda que o conteúdo
143 | matemático será voltado para casos reais e eu LHE GARANTO que você usará algum dia,
144 | porém antes você precisa entender como cada operação matemática funciona por trás dos panos,
145 | depois disso você sempre re-usará as funções previamente criadas, ou seja, para criar a próxima
146 | função você deverá obrigatóriamente ter criado as anteriores.
147 |
148 |
149 | ### Super Sayajin I
150 |
151 |
152 | 
153 |
154 |
155 | #### Módulo 1 - Funções e Lógica
156 |
157 | Nesse módulo ensinarei como você irá traduzir seu conhecimento prévio,
158 | principalmente em Matemática do Ensino Médio, em JavaScript Funcional.
159 |
160 | Esse módulo É **OBRIGATÓRIO** para quem:
161 |
162 | - Não saiba a definição de função e/ou conjunto;
163 | - Não sabe como compor operações matemáticas complexas usando apenas soma e números negativos;
164 | - Não tem lógica matemática forte
165 |
166 | ###### Quantidade de aulas: pelo menos 20.
167 |
168 | #### Tópicos
169 |
170 | ##### Matemática Discreta
171 |
172 | Vamos aprender como criar TODAS as operações mais utilizadas na Matemática
173 | e como trabalhar com o tipo `Number`, para isso inciaremos direto na função,
174 | para que o aluno entenda que esse é o conceito mais importante que ele precisa.
175 |
176 | As primeiras funções irão utilizar os números passados por parâmetro para que ele
177 | não precise iniciar nenhuma constante que não seja a função, só depois disso que você
178 | aprenderá a trabalhar com o tipo `Number`, encapsulando e usando suas principais funções.
179 |
180 | Depois iremos aprender a parte de coleções de números e conjuntos, onde emularemos
181 | o conceito de conjutos com `Array` e `Set`, pois o `Set` não possui NENHUMA das operações
182 | de conjuntos, como: adição, subtração e intersecção.
183 |
184 | Além disso eu ensinarei como podemos inferir fórmulas e resolver problemas matemáticos/físicos
185 | sem a necessidade de utilização da fórmula.
186 |
187 | > **Se você não sair MONSTR(A|O) em lógica matemática e booleana eu programarei só em JAVA!**
188 |
189 | ###### Conceitos
190 |
191 | - Constante;
192 | - nada de `var` **aqui!**
193 | - Função;
194 | - sempre pura!
195 | - Números;
196 | - Operações matemáticas:
197 | - soma, subtração, multiplicação, divisão, exponenciação e radiciação;
198 | - todas baseadas apenas na soma;
199 | - Boolean;
200 | - Lógica: matemática e booleana;
201 | - Conjuntos;
202 | - Operaçes com Conjuntos;
203 | - Correlações entre os números;
204 | - Matemática: como inferir fórmulas baseando-se nos conceitos.
205 | - Física: como inferir fórmulas baseando-se nos conceitos.
206 |
207 | ###### JavaScript
208 |
209 | - `while`/`for`;
210 | - `Function`;
211 | - `Number`;
212 | - `Array`;
213 | - `Set`.
214 |
215 | #### Pré-requisitos
216 |
217 | - Ensino Médio (cursando ou completo)
218 | - Não ter medo da Matemática pq ela é uma LINDA!
219 |
220 | #### Artigo
221 |
222 | Sim além dos exercícios que serão passados em cada aula ainda teremos **pelo menos**
223 | um artigo sobre algum dos temas abordados.
224 |
225 |
226 | #### Projeto Final
227 |
228 | Criação de uma calculadora com o máximo possível de funções matemáticas e físicas, cada aluno
229 | deverá criar pelo menos 2 funções novas.
230 |
231 |
232 |
233 |
234 |
235 |
236 |
237 |
238 |
239 | #### Módulo 2 - Estatística & Estrutura de Dados
240 | ##### Super Saiyajin Dai Ni Dankai (第2形態)
241 |
242 | Nesse módulo mostrarei como criar funções de Estatística baseando-se apenas
243 | na sua explicação e porque a estatística é a base para se usar as Redes Neurais
244 | e muito provavelmente no futuro a programação seja mais probabilística do que determinística.
245 |
246 | Com isso você aprenderá a organizar seus dados e retirar informações em cima de um conjunto
247 | de dados numéricos.
248 |
249 | ###### Objetivo
250 |
251 | Construir uma calculadora, via API, com a maiorias das funções de Matemática Estatística utilizadas
252 | pela Inteligência Artificial para que não precisemos depender do *Python* ou *R* para isso.
253 |
254 | ###### Conceitos
255 |
256 | - Recursividade;
257 | - Métodos de Matriz;
258 | - Média;
259 | - Moda;
260 | - Desvio Padrão;
261 | - Como inferir fórmulas baseando-se em conceitos;
262 | - Organização e estruturação dos dados;
263 | - etc.
264 |
265 | ##### Química - INCOMPLETO
266 |
267 | - Estruturação dos dados dos átomos;
268 | - Estruturação dos dados das moléculas;
269 | - Reações Químicas Inorgânicas: síntese e decomposição;
270 | - Distribuição Eletrônica;
271 | - Balanceamento de Reações;
272 | - Cálculo de Lei de Hess.
273 |
274 | ###### JavaScript
275 |
276 | - `let`;
277 | - `map`/`filter`/`reduce`/`concat`/etc;
278 | - `Object`;
279 | - `Math`;
280 | - `Symbol`.
281 |
282 | ##### Projeto Final
283 |
284 |
285 | [Uma Tabela Periódica diferente utilizando-se UX e API](https://github.com/Webschool-io/Elementos-Quimica).
286 |
287 |
288 |
289 |
290 |
291 |
292 |
293 |
294 | #### Módulo 3 - Biologia e Arquitetura de API - INCOMPLETO
295 | ##### Super Saiyajin Dai San Dankai (超サイヤ人第3段階)
296 |
297 |
298 | ##### Pré-requisitos
299 |
300 | - Conclusão do Módulo 2
301 |
302 | ##### Biologia
303 |
304 |
305 | ##### JavaScript
306 |
307 |
308 |
309 |
310 |
311 |
312 |
313 |
314 |
315 |
316 |
317 | #### Módulo 4 - O JavaScript nú - INCOMPLETO
318 | ##### Super Saiyajin Full Power (超サイヤ人フルパワ)
319 |
320 | Nesse módulo aprenderemos como o JavaScript funciona por trás das cortinas, tanto
321 | no navegador como no Node.js
322 |
323 | ###### JavaScript
324 |
325 | - Async
326 | - Call Stack
327 | - EventLoop
328 | - Events
329 | - Promises
330 | - Prototype
331 |
332 |
333 |
334 |
335 |
336 |
337 |
338 |
339 |
340 |
341 | ### Super Saiyajin II - INCOMPLETO
342 |
343 |
344 | 
345 |
346 |
347 | Vários conceitos teóricos da Programação Funcional serão explicados e implementados, como:
348 |
349 | - Aridade
350 | - Immutable data
351 | - Pipe/Compose
352 | - Currying
353 | - Partial application
354 | - Trampoline
355 | - Y-Combinator
356 | - TCO
357 | - [FantasyLand](https://github.com/fantasyland/fantasy-land)
358 |
359 |
360 | ##### Pré-requisitos
361 |
362 | - Conclusão do Nível Super Saiyajin I
363 |
364 |
365 |
366 |
367 |
368 |
369 |
370 |
371 |
372 |
373 |
374 | ### Super Sayajin III - INCOMPLETO
375 |
376 |
377 | 
378 |
379 |
380 |
381 | ##### Pré-requisitos
382 |
383 | - Conclusão do Nível Super Saiyajin II
384 |
385 | #### Módulo 1 - NoSQL
386 |
387 | - MongoDb
388 | - Redis
389 | - Neo4J
390 |
391 | #### Módulo 2 - Arquitetura
392 |
393 | - Arquitetura Backend (Redux)
394 | - Atomic Fucking Design
395 | - Programação Reativa
396 |
397 |
398 |
399 |
400 |
401 |
402 |
403 |
404 |
405 |
406 |
407 |
408 | ### Super Sayajin IV - INCOMPLETO
409 |
410 |
411 | 
412 |
413 |
414 | - Teoria das Categorias
415 | - Point-free programming,
416 | - Morphisms,
417 | - Data structures
418 |
419 |
420 | ##### Pré-requisitos
421 |
422 | - Conclusão do Nível Super Saiyajin III
423 |
424 |
425 |
426 |
427 |
428 |
429 |
430 |
431 |
432 |
433 | ### Super Sayajin V - INCOMPLETO
434 |
435 |
436 | 
437 |
438 |
439 | ##### Pré-requisitos
440 |
441 | - Conclusão do Nível Super Saiyajin IV
442 |
443 | #### Ementa
444 |
445 | - Socket.io
446 | - WebRTC
447 | - Webtorrent
448 | - Blockchain
449 | - Redes Neurais
450 |
451 | ### Certificado
452 |
453 | O aluno receberá um certificado mediante a entrega de todos os requisitos obrigatórios.
454 |
455 |
456 | # Forma de pagamento
457 |
458 | Será feito via depósito diretamente na conta do professor. O valor de investimento do curso é 35R$.
459 |
460 | ## Exercícios
461 |
462 |
463 | ## Suporte
464 |
465 | O curso conta com o suporte da própria comunidade e também dos professores da Webschool através do [Telegram](https://t.me/forumwebschool) e do nosso [Fórum](https://github.com/Webschool-io/forum). Vamos utilizar as Issues nosso repositorio [Fórum](https://github.com/Webschool-io/forum) para poder documentar as duvidas, assim podendo manter um histórico que possa ajudar outras pessoas que venham a ter a mesma dúvida que você. Além disso o nosso fórum e conectado com o grupo do telegram para que sua dúvida possa ser respondida facilmente.
466 |
467 | ## Apoio
468 |
469 | Entre em contato para apoiar esse curso.
470 |
--------------------------------------------------------------------------------
/Super Sayajin I/Modulo 01/README.md:
--------------------------------------------------------------------------------
1 | 
2 |
3 |
4 | # Super Sayajin I
5 |
6 |
7 |
8 |
9 |
10 | ## Módulo 1 - Funções e Lógica
11 |
12 | Nesse módulo ensinarei como você irá traduzir seu conhecimento prévio,
13 | principalmente em Matemática do Ensino Médio, em JavaScript Funcional.
14 |
15 | Esse módulo É **OBRIGATÓRIO** para quem:
16 |
17 | - Não saiba a definição de função e/ou conjunto;
18 | - Não sabe como compor operações matemáticas complexas usando apenas soma e números negativos;
19 | - Não tem lógica matemática forte
20 |
21 |
22 | ### Conteúdo
23 |
24 | #### Matemática Discreta
25 |
26 | Vamos aprender como criar TODAS as operações mais utilizadas na Matemática
27 | e como trabalhar com o tipo `Number`, para isso inciaremos direto na função,
28 | para que o aluno entenda que esse é o conceito mais importante que ele precisa.
29 |
30 | As primeiras funções irão utilizar os números passados por parâmetro para que ele
31 | não precise iniciar nenhuma constante que não seja a função, só depois disso que você
32 | aprenderá a trabalhar com o tipo `Number`, encapsulando e usando suas principais funções.
33 |
34 | Depois iremos aprender a parte de coleções de números e conjuntos, onde emularemos
35 | o conceito de conjutos com `Array` e `Set`, pois o `Set` não possui NENHUMA das operações
36 | de conjuntos, como: adição, subtração e intersecção.
37 |
38 | ##### Conceitos
39 |
40 | - Constante;
41 | - nada de `var` **aqui!**
42 | - Função;
43 | - sempre pura!
44 | - Números;
45 | - Operações matemáticas:
46 | - soma, subtração, multiplicação, divisão, exponenciação e radiciação;
47 | - todas baseadas apenas na soma;
48 | - Boolean;
49 | - Lógica: matemática e booleana;
50 | - Conjuntos;
51 | - Operaçes com Conjuntos;
52 | - Física: como inferir fórmulas baseando-se em conceitos.
53 |
54 | ##### JavaScript
55 |
56 | - `while`/`for`;
57 | - `Function`;
58 | - `Number`;
59 | - `Array`;
60 | - `Set`.
61 |
62 | #### Pré-requisitos
63 |
64 | - Ensino Médio (cursando ou completo)
65 | - Não ter medo da Matemática pq ela é uma LINDA!
66 |
67 | #### Artigo
68 |
69 | Sim além dos exercícios que serão passados em cada aula ainda teremos **pelo menos**
70 | um artigo sobre algum dos temas abordados.
71 |
72 |
73 | #### Projeto Final
74 |
75 | Criação de uma calculadora com o máximo possível de funções matemáticas e físicas, cada aluno
76 | deverá criar pelo menos 2 funções novas.
77 |
78 |
79 |
80 |
81 |
82 |
83 |
84 |
85 |
86 | ### Aulas
87 |
88 | #### Aula 01 - Conhecendo funções anônimas
89 |
90 | ##### O que é uma função?
91 |
92 |
93 |
94 | > **f( x ) = y**
95 |
96 |
97 |
98 | > Uma função ou aplicação é uma relação de um conjunto `A` com um conjunto `B`.
99 |
100 | *fonte: [Função (matemática) - Wikipedia](https://pt.wikipedia.org/wiki/Fun%C3%A7%C3%A3o_(matem%C3%A1tica))*
101 |
102 |
103 |
104 | 
105 |
106 |
107 |
108 | Podemos imaginar que o conjunto `A` é o conjunto dos valores dos nossos
109 | parâmetros e o conjunto `B` é o conjunto dos valores dos resultados.
110 |
111 | Logo essa relação entre esses dois conjuntos pode também ser
112 | uma transformação, filtragem, etc. Por exemplo:
113 |
114 |
115 | 
116 |
117 | Nesse caso temos duas funções:
118 |
119 | - uma filtra os números pares;
120 | - a outra filtra os números ímpares;
121 |
122 | Essas duas funções utilizam o mesmo conjunto de entrada, o conjunto dos números Naturais e suas respostas são **sub-conjuntos** dos números Naturais.
123 |
124 | > Você sabe que temos outros conjuntos numéricos também né?!
125 |
126 |
127 | - Conjunto dos Naturais;
128 | - Conjunto dos Inteiros;
129 | - Conjunto dos Racionais;
130 | - Conjunto dos Irracionais;
131 | - Conjunto dos Reais ;
132 |
133 |
134 |
135 | ##### Entendendo as operações matemáticas básicas
136 |
137 | - soma:
138 | - ( x, y ) => x + y
139 | - ( y ) => ( x ) => x + y
140 | - subtração:
141 | - ( x, y ) => soma( x, -y )
142 | - ( y ) => ( x ) => soma( x )( -y )
143 | + invertendo essa operação
144 | - multiplicação: ( utilizando apenas a soma )
145 | - ( x, y ) => x * y
146 | - ( y ) => ( x ) => ...
147 | + invertendo essa operação
148 | - divisão: ( utilizando apenas a soma )
149 | - ( x, y ) => x / y
150 | - ( y ) => ( x ) => ...
151 | + invertendo essa operação
152 |
153 | > Na lógica matemática e na ciência da computação, lambda cálculo , também escrito como cálculo-λ é um sistema formal que estuda funções recursivas computáveis, no que se refere a teoria da computabilidade, e fenômenos relacionados, como variáveis ligadas e substituição. Sua principal característica são as entidades que podem ser utilizadas como argumentos e retornadas como valores de outras funções.
154 | >
155 | > A parte relevante de lambda cálculo para computação ficou conhecida como lambda cálculo não-tipado. O lambda cálculo tipado e o não-tipado tem suas ideias aplicadas nos campos da lógica, teoria da recursão (computabilidade) e linguística, e tem tido um grande papel no desenvolvimento da teoria de linguagens de programação (com a versão não-tipada sendo a inspiração original para programação funcional, em particular Lisp...
156 | >
157 | > ...
158 | >
159 | > Como os nomes de funções são uma mera conveniência, o lambda cálculo não tem interesse em nomear uma função. Já que todas as funções esperando mais de um argumento podem ser transformadas em funções equivalentes recebendo uma única entrada (via Currying), o lambda cálculo não tem interesse em criar funções que aceitam mais de um argumento.
160 |
161 | *fonte: [Cálculo lambda - Wikipedia](https://pt.wikipedia.org/wiki/C%C3%A1lculo_lambda)*
162 |
163 |
164 |
165 | > **Entendeu o porquê estou mostrando como criar essas operações
166 | básicas onde recebo apenas um parâmetro por vez?**
167 |
168 |
169 |
170 | Caso você ainda não tenha entendido irei demonstrar praticamente.
171 |
172 | Imagine que você quer ter uma função que sempre multiple por `2` algum valor.
173 |
174 | ```js
175 |
176 | const double = ( x ) => x * 2
177 |
178 | ```
179 |
180 | > Muito fácil né?
181 | >
182 | > Agora vamos fazer uma que multiplique por 3 e outra por 10.
183 |
184 | ```js
185 |
186 | const double = ( x ) => x * 2
187 | const triple = ( x ) => x * 3
188 | const tenTimes = ( x ) => x * 10
189 |
190 | ```
191 |
192 | Podemos facilmente criar uma função para reaproveitar isso, dessa forma:
193 |
194 |
195 | ```js
196 |
197 | const times = ( y ) => ( x ) => x * y
198 | const double = times( 2 )
199 | const triple = times( 3 )
200 | const tenTimes = times( 10 )
201 |
202 | ```
203 |
204 |
205 | ##### Desafio
206 |
207 | Criar a função de divisão utilizando apenas a função de soma,
208 | onde ela receba 2 valores inteiros e consiga retornar um
209 | valor decimal. Por exemplo: `5 / 2 = 2.5`
210 |
211 | Além disso explique como dois valores do conjunto dos Números Naturais
212 | transformou-se em um valor que não está contido nesse grupo e qual o grupo que ele pertence.
213 |
214 | > **Lembrando que a ÚNICA função aceita dentro da divisão será a da soma!**
215 |
216 |
217 |
218 |
219 | ###### Oozaru
220 |
221 | 
222 |
223 | Como demonstrei anterioremente, utilizamos funções
224 | anônimas, que definimos em constantes, pois isso nos remetei ao [Cálculo lambda](https://pt.wikipedia.org/wiki/C%C3%A1lculo_lambda) que é a base da
225 | Programação Funcional.
226 |
227 | Logo preciso também lhe mostrar do outro jeito, usando `function`.
228 |
229 | > Por isso a `function` está na seção ***Oozaru***! Pois você pode
230 | > usar mas **EU** não lhe aconselho.
231 | >
232 |
233 |
234 |
235 |
236 |
237 |
238 | #### Aula 02 - Trabalhando com o tipo *Number*
239 |
240 | #####Entendendo as operações matemáticas não tão básicas
241 |
242 | - divisão
243 | - de inteiros resultando decimal
244 | - exponenciação
245 | + soma
246 | + subtração
247 | + multiplicação
248 | + divisão
249 | + invertendo essa operação
250 | - radiciação
251 | + como criar uma função genérica utilizando `Math.pow`
252 | + invertendo essa operação
253 |
254 |
255 |
256 |
257 |
258 | #### Aula 03 - Entendendo as operações matemáticas não tão básicas
259 |
260 | - equação do primeiro grau
261 | - equação do segundo grau
262 | - bhaskara
263 |
264 |
265 |
266 |
267 |
268 |
269 |
270 | #### Aula 04 - Mas isso é Lógico!
271 |
272 | > Se você algum dia já falou essa frase: isso é lógico!
273 | >
274 | > Sabe perfeitamente que falou isso porque aquilo esatava na sua cara!
275 | > Não tinha como pensar de forma diferente.
276 | >
277 |
278 |
279 |
280 | Então eu venho lhe falar que a Lógica é a disciplina que nos ensina
281 | a ponderar as premissas lógicas que precisamos avaliar para podermos
282 | ter um resultado final único.
283 |
284 | Por exemplo:
285 |
286 |
287 |
288 | > Se eu tiver dinheiro E estiver passando Logan, então irei ver.
289 |
290 |
291 |
292 | Nisso eu lhe pergunto:
293 |
294 |
295 |
296 | >Se estiver passando Logan e eu não tiver dinheiro, o que acontecerá?
297 |
298 |
299 |
300 |
301 | > **Exatamente! Eu não poderei ver o filme do Logan**
302 | >
303 | > Por quê?
304 |
305 |
306 |
307 |
--------------------------------------------------------------------------------
/Super Sayajin I/Modulo 01/aula01.md:
--------------------------------------------------------------------------------
1 | 
2 |
3 | # Aula 01 - Conhecendo funções
4 |
5 | ## O que é uma função?
6 |
7 |
8 |
9 | > **f( x ) = y**
10 |
11 |
12 |
13 | > Uma função ou aplicação é uma relação de um conjunto `A` com um conjunto `B`.
14 |
15 | *fonte: [Função (matemática) - Wikipedia](https://pt.wikipedia.org/wiki/Fun%C3%A7%C3%A3o_(matem%C3%A1tica))*
16 |
17 |
18 |
19 | 
20 |
21 |
22 |
23 | Podemos imaginar que o conjunto `A` é o conjunto dos valores dos nossos
24 | parâmetros e o conjunto `B` é o conjunto dos valores dos resultados.
25 |
26 | Logo essa relação entre esses dois conjuntos pode também ser
27 | uma transformação, filtragem, etc. Por exemplo:
28 |
29 |
30 | 
31 |
32 | Nesse caso temos duas funções:
33 |
34 | - uma filtra os números pares;
35 | - a outra filtra os números ímpares;
36 |
37 | Essas duas funções utilizam o mesmo conjunto de entrada, o conjunto dos números Naturais e suas respostas são **sub-conjuntos** dos números Naturais.
38 |
39 | > Você sabe que temos outros conjuntos numéricos também né?!
40 |
41 |
42 | - Conjunto dos Naturais;
43 | - Conjunto dos Inteiros;
44 | - Conjunto dos Racionais;
45 | - Conjunto dos Irracionais;
46 | - Conjunto dos Reais ;
47 |
48 |
49 |
50 | ## Entendendo as operações matemáticas básicas
51 |
52 | > Na lógica matemática e na ciência da computação, lambda cálculo , também escrito como cálculo-λ é um sistema formal que estuda funções recursivas computáveis, no que se refere a teoria da computabilidade, e fenômenos relacionados, como variáveis ligadas e substituição. Sua principal característica são as entidades que podem ser utilizadas como argumentos e retornadas como valores de outras funções.
53 | >
54 | > A parte relevante de lambda cálculo para computação ficou conhecida como lambda cálculo não-tipado. O lambda cálculo tipado e o não-tipado tem suas ideias aplicadas nos campos da lógica, teoria da recursão (computabilidade) e linguística, e tem tido um grande papel no desenvolvimento da teoria de linguagens de programação (com a versão não-tipada sendo a inspiração original para programação funcional, em particular Lisp...
55 | >
56 | > ...
57 | >
58 | > Como os nomes de funções são uma mera conveniência, o lambda cálculo não tem interesse em nomear uma função. Já que todas as funções esperando mais de um argumento podem ser transformadas em funções equivalentes recebendo uma única entrada (via Currying), o lambda cálculo não tem interesse em criar funções que aceitam mais de um argumento.
59 |
60 | *fonte: [Cálculo lambda - Wikipedia](https://pt.wikipedia.org/wiki/C%C3%A1lculo_lambda)*
61 |
62 |
63 |
64 | ### Reduzindo à apenas uma operação
65 |
66 |
67 |
68 |
69 | > **Você já pensou que qualquer operação matemática pode ser**
70 | > **reduzida apenas em soma e subtração???**
71 |
72 |
73 |
74 |
75 |
76 | 
77 |
78 |
79 |
80 |
81 |
82 | > Vou dar uma dica: pode usar apenas soma e números **negativos**!
83 |
84 | > Dica matadora essa né?
85 |
86 |
87 |
88 |
89 |
90 | Você pode usar número negativo pois seu sinal é
91 | [representado por 64 bits, sendo apenas 1 para seu sinal](http://www.2ality.com/2012/04/number-encoding.html).
92 |
93 |
94 |
95 |
96 | 
97 |
98 |
99 |
100 |
101 | Então vamos pensar:
102 |
103 | ```js
104 | 5-4=1
105 | 5+4=9
106 | 5+(-4)=1
107 | ```
108 |
109 |
110 | É nessa hora que você lembra do Ensino Médio e a regra de sinais:
111 |
112 | - número negativo com número negativo (1° caso)
113 |
114 | - número positivo com número positivo (2° caso)
115 |
116 | - número negativo com número positivo ou vice-versa (3° caso)
117 |
118 |
119 | Primeiro caso:
120 |
121 | > Quando temos dois números negativos repetimos o sinal de
122 | subtração e somamos esses dois números.
123 |
124 |
125 |
126 | ```
127 | -12 + -8 = - (12 + 8) = - 20
128 | -10 + -16 = - (10 + 16) = - 26
129 | -15 + -2 = - (15 + 2) = - 17
130 | -11 + -46 = - (11 + 46) = - 57
131 | ```
132 |
133 |
134 |
135 | Segundo caso:
136 |
137 | > Quando temos dois números positivos repetimos o sinal de adição
138 | e somamos esses dois números.
139 |
140 | ```
141 | +12 + 8 = + (12 + 8) = + 20
142 | +10 + 16 = + (10 + 16) = + 26
143 | +15 + 2 = + (15 + 2) = + 17
144 | +11 + 46 = + (11 + 46) = + 57
145 | ```
146 |
147 |
148 | Terceiro caso:
149 |
150 | > Quando temos um número negativo e outro positivo ou vice-versa devemos repetir o sinal do maior número em módulo e depois devemos subtrair o maior número (em módulo) pelo menor número (também em módulo).
151 |
152 | > O módulo de um número nada mais é do que pegar o valor positivo desse número. O módulo é representado por duas barras dispostas uma no início e outra no fim do número. |-2| === 2
153 |
154 |
155 | ```
156 | +12 + -8 = + (|12| - |-8|) = 4
157 | +10 + -16 = - (|-16| - |10|) = - 6
158 | +15 + -2 = + (|15| - |-2|) = + 13
159 | +11 + -46 = - (|-46| - |11|) = - 35
160 | ```
161 |
162 |
163 |
164 |
165 | > **A partir desse terceiro caso já matamos a charada!**
166 |
167 |
168 |
169 |
170 | Agora eu lhe pergunto:
171 |
172 | > **Por que um número negativo somado com outro negativo da positivo?**
173 |
174 |
175 |
176 |
177 |
178 | Vamos imaginar o seguinte:
179 |
180 |
181 |
182 | Na lógica possuimos o operador de negação, que apenas **inverte** um valor,
183 | por exemplo: `!false === true`.
184 |
185 |
186 |
187 | > Negação, em lógica e matemática, é uma operação unária sobre valores lógicos,
188 | > por exemplo o valor lógico de uma proposição. Se a proposição é verdadeira,
189 | > então o operador lógico negação produz o valor falso, e vice versa.
190 |
191 | *fonte: [Negação - Wikipedia](https://pt.wikipedia.org/wiki/Nega%C3%A7%C3%A3o)*
192 |
193 |
194 |
195 | Até ai tudo bem né?
196 |
197 |
198 |
199 |
200 | **Agora vamos estender esse conceito para os números.**
201 |
202 |
203 |
204 | Imagine que a negação de um número é o seu inverso e qual o inverso de 4?
205 |
206 | Se formos pegar o plano cartesiano no eixo x, o valor de algo é a sua
207 | distância até o ponto `0` nesse eixo. Logo se quisermos inverter esse valor
208 | basta pegarmos essa mesma distância e partirmos do `0` até o valor dessa
209 | distância porém seguindo o eixo x negativo.
210 |
211 |
212 |
213 | > Simples não???
214 |
215 |
216 |
217 | Então pense aqui comigo, basta multiplicarmos por `-1` para invertermos
218 | o valor de um número. Sabendo disso acompanhe abaixo:
219 |
220 | ```
221 | x = -1
222 |
223 | -10 + -4 = -14
224 | ~10 + ~4 = ~(10 + 4) = ~(14) = -14
225 | 10x + 4x = 14x = 14 * -1 = -14
226 |
227 | -10 * -4 = 40
228 | ~10 * ~4 = ~ * ~(10 * 4) = ~^2(40) = 40
229 | 10x * 4x = 40x^2 = 40 * -1 * -1 = -40 * -1 = 40
230 |
231 | ```
232 |
233 |
234 |
235 | Perceba que neguei o valor dos valores negativos e depois troquei esse
236 | operador de negação pelo `x` para poder provar lógica-matematicamente.
237 |
238 | Na soma `10x + 4x` o resultado é `14x` e na multiplicação é `40x^2`
239 | sabendo que o `x` é a negação então na soma ele apenas nega o valor e
240 | na multiplicação ele nega a negação, pois temos uma dupla negações.
241 |
242 | Depois dessa análise podemos facilmente escrever uma função para isso:
243 |
244 | ```js
245 |
246 | const deny = ( num ) => num * -1
247 |
248 | const x = deny( 10 )
249 | const y = deny( 4 )
250 |
251 | const sum = ( x, y ) => x + y
252 | const times = ( x, y ) => x * y
253 |
254 | const sumResult = sum( x, y )
255 | const timesesult = times( x, y )
256 |
257 | console.log('sumResult', sumResult)
258 | console.log('timesesult', timesesult)
259 |
260 | ```
261 |
262 | > Beeeeem simples, concorda?
263 |
264 | Com isso conseguimos
265 |
266 |
267 |
268 |
269 | ```js
270 |
271 | const deny = ( num ) => num * -1
272 |
273 | const x = deny( 10 )
274 | const y = deny( 4 )
275 |
276 | const sum = ( x, y ) => x + y
277 | const times = ( x, y ) => x * y
278 |
279 | const sumResult = sum( x, y )
280 | const timesesult = times( x, y )
281 |
282 | console.log('sumResult', sumResult)
283 | console.log('timesesult', timesesult)
284 |
285 | ```
286 |
287 |
288 |
289 |
290 | ### Operações básicas
291 |
292 | - soma:
293 | - ( x, y ) => x + y
294 | - ( y ) => ( x ) => x + y
295 | - subtração:
296 | - ( x, y ) => soma( x, -y )
297 | - ( y ) => ( x ) => soma( x )( -y )
298 | + invertendo essa operação
299 | - multiplicação: ( utilizando apenas a soma )
300 | - ( x, y ) => x * y
301 | - ( y ) => ( x ) => ...
302 | + invertendo essa operação
303 | - divisão: ( utilizando apenas a soma )
304 | - ( x, y ) => x / y
305 | - ( y ) => ( x ) => ...
306 | + invertendo essa operação
307 |
308 |
309 | Demonstrando com código:
310 |
311 | ```js
312 |
313 | const sum = ( x, y ) => x + y
314 | const sumParcial = ( y ) => ( x ) => x + y
315 |
316 | const minus = ( x, y ) => sum( x, -y )
317 | const minusParcial = ( y ) => ( x ) => sumParcial( -y )( x )
318 |
319 | ```
320 |
321 | > **Entendeu o porquê estou mostrando como criar essas operações**
322 | **básicas onde recebo apenas um parâmetro por vez?**
323 |
324 | > Lembrando que nós só poderemos usar funções que re-usem outras!
325 |
326 |
327 |
328 | Caso você ainda não tenha entendido ainda irei demonstrar praticamente.
329 |
330 | Imagine que você quer ter uma função que sempre multiple por `2` qualquer valor.
331 |
332 | ```js
333 |
334 | const double = ( x ) => x * 2
335 |
336 | ```
337 |
338 | Podemos facilmente criar uma função para reaproveitar isso, dessa forma:
339 |
340 |
341 | ```js
342 |
343 | const times = ( y ) => ( x ) => x * y
344 | const double = times( 2 )
345 | const triple = times( 3 )
346 | const tenTimes = times( 10 )
347 |
348 | ```
349 |
350 |
351 |
352 |
353 | > Agora vamos fazer uma que multiplique por 3 e outra por 10.
354 |
355 | ```js
356 |
357 | const times = ( y ) => ( x ) => x * y
358 | const double = times( 2 )
359 | const triple = times( 3 )
360 | const tenTimes = times( 10 )
361 |
362 | ```
363 |
364 |
365 |
366 |
367 | > **Muito simples né?**
368 |
369 | Perceba que quebramos uma função que possuía dois parâmetros
370 | em outras duas funções que recebem apenas um parâmetro cada.
371 |
372 |
373 |
374 |
375 |
376 | > **Então agora vamos escrever essa mesma função usando apenas a soma!**
377 |
378 |
379 |
380 |
381 | Para isso precisamos entender o **algoritmo** da multiplicação:
382 |
383 | ```
384 |
385 | Receba x e y
386 | Pegue o valor de x e some nele mesmo y vezes.
387 |
388 |
389 | ```
390 |
391 | Traduzindo para JavaScript:
392 |
393 |
394 | ```js
395 |
396 | const times = ( y ) => ( x ) => {
397 |
398 | let result = 0
399 |
400 | while ( y > 0 ) { // ( y )
401 | result += x
402 | y--
403 | }
404 |
405 | return result
406 | }
407 |
408 | console.log('3 times 4', times( 4 )( 3 ) )
409 |
410 | ```
411 |
412 | #### Reduzindo a multiplicação para a soma
413 |
414 | ```js
415 |
416 | const sum = ( y ) => ( x ) => x + y
417 |
418 | const times = ( y ) => ( x ) => {
419 |
420 | let result = 0
421 |
422 | const sumX = sum( result )
423 |
424 | while ( y > 0 ) { // ( y )
425 | result += sumX( x )
426 | y--
427 | }
428 |
429 | return result
430 | }
431 |
432 | console.log('3 times 4', times( 4 )( 3 ) )
433 |
434 | ```
435 |
436 |
437 |
438 |
439 | > **Conseguiu entender o [`while`](http://mdn.io/while)?**
440 |
441 |
442 |
443 |
444 | Ele é uma função de *looping* assim como o [`for`]() e o [`do while`], porém
445 | é diferente de funções iteradoras como:
446 |
447 | - [map](http://mdn.io/map);
448 | - [filter](http://mdn.io/filter);
449 | - [reduce](http://mdn.io/reduce);
450 | - [forEach](http://mdn.io/forof);
451 | - [for in](http://mdn.io/forin);
452 | - [for of](http://mdn.io/forof);
453 | - etc
454 |
455 | A diferença entre esses dois tipos de funções é que as funções de
456 | *looping* não precisam de uma estrutura de dados como base para iterar.
457 | Já as de iteração necessitam de uma estrutura iterável.
458 |
459 | Mostrai o mesmo exemplo com algumas dessas funções.
460 |
461 | Imagine que temos um *Array* de Objetos e precisamos antes de somar
462 | os salários retirar 10% do valor de cada um e depois fazer uma média.
463 |
464 | ```js
465 |
466 | const workers = [ 1000, 2500 , 10000 ]
467 |
468 | const withdraw = ( list, percent ) => {
469 |
470 | let counter = 0
471 | let newList = []
472 |
473 | while ( counter < list.length) {
474 | const percentValue = list[ counter ] * ( percent / 100 )
475 | const newSalary = list[ counter ] - percentValue
476 |
477 | newList[ counter ] = newSalary
478 | counter++
479 | }
480 |
481 | return newList
482 | }
483 |
484 | console.log( 'New Salaries: ', withdraw( workers, 10 ) )
485 |
486 | ```
487 |
488 | No código acima nós apenas criamos um *Array* novo com os valores
489 | dos valores calculados pela nossa função
490 |
491 | ```js
492 |
493 | const workers = [ 1000, 2500 , 10000 ]
494 |
495 | const sumAll = ( list, percent ) => {
496 |
497 | let counter = 0
498 | let total = 0
499 |
500 | while ( counter < list.length) {
501 | const percentValue = list[ counter ] * ( percent / 100 )
502 | const newSalary = list[ counter ] - percentValue
503 |
504 | total += newSalary
505 | counter++
506 | }
507 |
508 | return total
509 | }
510 |
511 | console.log( 'Sum of Salaries: ', sumAll( workers, 10 ) )
512 |
513 | ```
514 |
515 | ### Lembrete 1
516 |
517 | > Percebeu que não criamos **funções** porém não criamos nenhuma constante
518 | > para os valores que passaremos como parâmetro?
519 |
520 | Isso se deve graças a dois conceitos que são obrigatórios para uma linguagem
estar contida no Paradigma Funcional:
521 |
522 | - [First-class Function]()
523 | - [High-Order Function]()
524 |
525 | **Falarei melhor sobre esses conceitos na próxima aula!**
526 |
527 | ## Desafio
528 |
529 | Criar a função de divisão utilizando apenas a função de soma,
530 | onde ela receba 2 valores inteiros e consiga retornar um
531 | valor decimal. Por exemplo: `5 / 2 = 2.5`
532 |
533 | Além disso explique como dois valores do conjunto dos Números Naturais
534 | transformou-se em um valor que não está contido nesse grupo e qual o grupo que ele pertence.
535 |
536 | > **Lembrando que a ÚNICA função aceita dentro da divisão será a da soma!**
537 |
538 |
539 |
540 |
541 | ###### Oozaru
542 |
543 | 
544 |
545 | Como demonstrei anterioremente, utilizamos funções
546 | anônimas, que definimos em constantes, pois isso nos remetei ao [Cálculo lambda](https://pt.wikipedia.org/wiki/C%C3%A1lculo_lambda) que é a base da
547 | Programação Funcional.
548 |
549 | Logo preciso também lhe mostrar do outro jeito, usando `function`.
550 |
551 | > Por isso a `function` está na seção ***Oozaru***! Pois você pode
552 | > usar mas **EU** não lhe aconselho.
553 | >
554 |
555 |
556 |
557 |
558 |
559 |
560 | ## Exercícios
561 |
562 | 1) Demonstre, como visto nessa aula, a regra de sinais para a operação de divisão.
563 | Cobrindo os 3 casos explicados anteriormente.
564 |
565 | 2) Crie a função de dividir baseando-se no **SEU** algoritmo.
566 |
--------------------------------------------------------------------------------
/Super Sayajin I/Modulo 01/aula01/README.md:
--------------------------------------------------------------------------------
1 | 
2 |
3 | # Aula 01 - Conhecendo funções
4 |
5 | ## O que é uma função?
6 |
7 |
8 |
9 | > **f( x ) = y**
10 |
11 |
12 |
13 | > Uma função ou aplicação é uma relação de um conjunto `A` com um conjunto `B`.
14 |
15 | *fonte: [Função (matemática) - Wikipedia](https://pt.wikipedia.org/wiki/Fun%C3%A7%C3%A3o_(matem%C3%A1tica))*
16 |
17 |
18 |
19 | 
20 |
21 |
22 |
23 | Podemos imaginar que o conjunto `A` é o conjunto dos valores dos nossos
24 | parâmetros e o conjunto `B` é o conjunto dos valores dos resultados.
25 |
26 | Logo essa relação entre esses dois conjuntos pode também ser
27 | uma transformação, filtragem, etc. Por exemplo:
28 |
29 |
30 | 
31 |
32 | Nesse caso temos duas funções:
33 |
34 | - uma filtra os números pares;
35 | - a outra filtra os números ímpares;
36 |
37 | Essas duas funções utilizam o mesmo conjunto de entrada, o conjunto dos números Naturais e suas respostas são **sub-conjuntos** dos números Naturais.
38 |
39 | > Você sabe que temos outros conjuntos numéricos também né?!
40 |
41 |
42 | - Conjunto dos Naturais;
43 | - Conjunto dos Inteiros;
44 | - Conjunto dos Racionais;
45 | - Conjunto dos Irracionais;
46 | - Conjunto dos Reais ;
47 |
48 |
49 |
50 | ## Entendendo as operações matemáticas básicas
51 |
52 | > Na lógica matemática e na ciência da computação, lambda cálculo , também escrito como cálculo-λ é um sistema formal que estuda funções recursivas computáveis, no que se refere a teoria da computabilidade, e fenômenos relacionados, como variáveis ligadas e substituição. Sua principal característica são as entidades que podem ser utilizadas como argumentos e retornadas como valores de outras funções.
53 | >
54 | > A parte relevante de lambda cálculo para computação ficou conhecida como lambda cálculo não-tipado. O lambda cálculo tipado e o não-tipado tem suas ideias aplicadas nos campos da lógica, teoria da recursão (computabilidade) e linguística, e tem tido um grande papel no desenvolvimento da teoria de linguagens de programação (com a versão não-tipada sendo a inspiração original para programação funcional, em particular Lisp...
55 | >
56 | > ...
57 | >
58 | > Como os nomes de funções são uma mera conveniência, o lambda cálculo não tem interesse em nomear uma função. Já que todas as funções esperando mais de um argumento podem ser transformadas em funções equivalentes recebendo uma única entrada (via Currying), o lambda cálculo não tem interesse em criar funções que aceitam mais de um argumento.
59 |
60 | *fonte: [Cálculo lambda - Wikipedia](https://pt.wikipedia.org/wiki/C%C3%A1lculo_lambda)*
61 |
62 |
63 |
64 | ### Reduzindo à apenas uma operação
65 |
66 |
67 |
68 |
69 | > **Você já pensou que qualquer operação matemática pode ser**
70 | > **reduzida apenas em soma e subtração???**
71 |
72 |
73 |
74 |
75 |
76 | 
77 |
78 |
79 |
80 |
81 |
82 | > Vou dar uma dica: pode usar apenas soma e números **negativos**!
83 |
84 | > Dica matadora essa né?
85 |
86 |
87 |
88 |
89 |
90 | Você pode usar número negativo pois seu sinal é
91 | [representado por 64 bits, sendo apenas 1 para seu sinal](http://www.2ality.com/2012/04/number-encoding.html).
92 |
93 |
94 |
95 |
96 | 
97 |
98 |
99 |
100 |
101 | Então vamos pensar:
102 |
103 | ```js
104 | 5-4=1
105 | 5+4=9
106 | 5+(-4)=1
107 | ```
108 |
109 |
110 | É nessa hora que você lembra do Ensino Médio e a regra de sinais:
111 |
112 | - número negativo com número negativo (1° caso)
113 |
114 | - número positivo com número positivo (2° caso)
115 |
116 | - número negativo com número positivo ou vice-versa (3° caso)
117 |
118 |
119 | Primeiro caso:
120 |
121 | > Quando temos dois números negativos repetimos o sinal de
122 | subtração e somamos esses dois números.
123 |
124 |
125 |
126 | ```
127 | -12 + -8 = - (12 + 8) = - 20
128 | -10 + -16 = - (10 + 16) = - 26
129 | -15 + -2 = - (15 + 2) = - 17
130 | -11 + -46 = - (11 + 46) = - 57
131 | ```
132 |
133 |
134 |
135 | Segundo caso:
136 |
137 | > Quando temos dois números positivos repetimos o sinal de adição
138 | e somamos esses dois números.
139 |
140 | ```
141 | +12 + 8 = + (12 + 8) = + 20
142 | +10 + 16 = + (10 + 16) = + 26
143 | +15 + 2 = + (15 + 2) = + 17
144 | +11 + 46 = + (11 + 46) = + 57
145 | ```
146 |
147 |
148 | Terceiro caso:
149 |
150 | > Quando temos um número negativo e outro positivo ou vice-versa devemos repetir o sinal do maior número em módulo e depois devemos subtrair o maior número (em módulo) pelo menor número (também em módulo).
151 |
152 | > O módulo de um número nada mais é do que pegar o valor positivo desse número. O módulo é representado por duas barras dispostas uma no início e outra no fim do número. |-2| === 2
153 |
154 |
155 | ```
156 | +12 + -8 = + (|12| - |-8|) = 4
157 | +10 + -16 = - (|-16| - |10|) = - 6
158 | +15 + -2 = + (|15| - |-2|) = + 13
159 | +11 + -46 = - (|-46| - |11|) = - 35
160 | ```
161 |
162 |
163 |
164 |
165 | > **A partir desse terceiro caso já matamos a charada!**
166 |
167 |
168 |
169 |
170 | Agora eu lhe pergunto:
171 |
172 | > **Por que um número negativo somado com outro negativo da positivo?**
173 |
174 |
175 |
176 |
177 |
178 | Vamos imaginar o seguinte:
179 |
180 |
181 |
182 | Na lógica possuimos o operador de negação, que apenas **inverte** um valor,
183 | por exemplo: `!false === true`.
184 |
185 |
186 |
187 | > Negação, em lógica e matemática, é uma operação unária sobre valores lógicos,
188 | > por exemplo o valor lógico de uma proposição. Se a proposição é verdadeira,
189 | > então o operador lógico negação produz o valor falso, e vice versa.
190 |
191 | *fonte: [Negação - Wikipedia](https://pt.wikipedia.org/wiki/Nega%C3%A7%C3%A3o)*
192 |
193 |
194 |
195 | Até ai tudo bem né?
196 |
197 |
198 |
199 |
200 | **Agora vamos estender esse conceito para os números.**
201 |
202 |
203 |
204 | Imagine que a negação de um número é o seu inverso e qual o inverso de 4?
205 |
206 | Se formos pegar o plano cartesiano no eixo x, o valor de algo é a sua
207 | distância até o ponto `0` nesse eixo. Logo se quisermos inverter esse valor
208 | basta pegarmos essa mesma distância e partirmos do `0` até o valor dessa
209 | distância porém seguindo o eixo x negativo.
210 |
211 |
212 |
213 | > Simples não???
214 |
215 |
216 |
217 | Então pense aqui comigo, basta multiplicarmos por `-1` para invertermos
218 | o valor de um número. Sabendo disso acompanhe abaixo:
219 |
220 | ```
221 | x = -1
222 |
223 | -10 + -4 = -14
224 | ~10 + ~4 = ~(10 + 4) = ~(14) = -14
225 | 10x + 4x = 14x = 14 * -1 = -14
226 |
227 | -10 * -4 = 40
228 | ~10 * ~4 = ~ * ~(10 * 4) = ~^2(40) = 40
229 | 10x * 4x = 40x^2 = 40 * -1 * -1 = -40 * -1 = 40
230 |
231 | ```
232 |
233 |
234 |
235 | Perceba que neguei o valor dos valores negativos e depois troquei esse
236 | operador de negação pelo `x` para poder provar lógica-matematicamente.
237 |
238 | Na soma `10x + 4x` o resultado é `14x` e na multiplicação é `40x^2`
239 | sabendo que o `x` é a negação então na soma ele apenas nega o valor e
240 | na multiplicação ele nega a negação, pois temos uma dupla negações.
241 |
242 | Depois dessa análise podemos facilmente escrever uma função para isso:
243 |
244 | ```js
245 |
246 | const deny = ( num ) => num * -1
247 |
248 | const x = deny( 10 )
249 | const y = deny( 4 )
250 |
251 | const sum = ( x, y ) => x + y
252 | const times = ( x, y ) => x * y
253 |
254 | const sumResult = sum( x, y )
255 | const timesesult = times( x, y )
256 |
257 | console.log('sumResult', sumResult)
258 | console.log('timesesult', timesesult)
259 |
260 | ```
261 |
262 | > Beeeeem simples, concorda?
263 |
264 | Com isso conseguimos
265 |
266 |
267 |
268 |
269 | ```js
270 |
271 | const deny = ( num ) => num * -1
272 |
273 | const x = deny( 10 )
274 | const y = deny( 4 )
275 |
276 | const sum = ( x, y ) => x + y
277 | const times = ( x, y ) => x * y
278 |
279 | const sumResult = sum( x, y )
280 | const timesesult = times( x, y )
281 |
282 | console.log('sumResult', sumResult)
283 | console.log('timesesult', timesesult)
284 |
285 | ```
286 |
287 |
288 |
289 |
290 | ### Operações básicas
291 |
292 | - soma:
293 | - ( x, y ) => x + y
294 | - ( y ) => ( x ) => x + y
295 | - subtração:
296 | - ( x, y ) => soma( x, -y )
297 | - ( y ) => ( x ) => soma( x )( -y )
298 | + invertendo essa operação
299 | - multiplicação: ( utilizando apenas a soma )
300 | - ( x, y ) => x * y
301 | - ( y ) => ( x ) => ...
302 | + invertendo essa operação
303 | - divisão: ( utilizando apenas a soma )
304 | - ( x, y ) => x / y
305 | - ( y ) => ( x ) => ...
306 | + invertendo essa operação
307 |
308 |
309 | Vou demonstrar as duas formas de se escrever essas operações:
310 |
311 | ```js
312 |
313 | const sum = ( x, y ) => x + y
314 | const sumParcial = ( y ) => ( x ) => x + y
315 |
316 | const minus = ( x, y ) => sum( x, -y )
317 | const minusParcial = ( y ) => ( x ) => sumParcial( -y )( x )
318 |
319 | ```
320 |
321 | > **Entendeu o porquê estou mostrando como criar essas operações**
322 | **básicas onde recebo apenas um parâmetro por vez?**
323 |
324 | > Lembrando que nós só poderemos usar funções que re-usem outras!
325 |
326 |
327 |
328 | Caso você ainda não tenha entendido ainda irei demonstrar praticamente.
329 |
330 | Imagine que você precise de uma função que sempre multiple por `2` qualquer valor.
331 |
332 | ```js
333 |
334 | const double = ( x ) => x * 2
335 |
336 | ```
337 |
338 | Podemos facilmente criar uma função para reaproveitar isso, dessa forma:
339 |
340 |
341 | ```js
342 |
343 | const times = ( y ) => ( x ) => x * y
344 |
345 | const double = times( 2 )
346 |
347 | const doubleResult = double( 5 )
348 |
349 | console.log( 'doubleResult', doubleResult ) // doubleResult 10
350 |
351 | ```
352 |
353 |
354 |
355 |
356 | > Agora vamos fazer uma que multiplique por 3 e outra por 10.
357 |
358 |
359 |
360 |
361 | ```js
362 |
363 | const times = ( y ) => ( x ) => x * y
364 |
365 | const double = times( 2 )
366 | const triple = times( 3 )
367 | const tenTimes = times( 10 )
368 |
369 | const doubleResult = double( 5 )
370 | const tripleResult = triple( 5 )
371 | const tenTimesResult = tenTimes( 5 )
372 |
373 | console.log( 'doubleResult', doubleResult ) // doubleResult 10
374 | console.log( 'tripleResult', tripleResult ) // tripleResult 15
375 | console.log( 'tenTimesResult', tenTimesResult ) // tenTimesResult 50
376 |
377 | ```
378 |
379 |
380 |
381 |
382 | > **Muito simples reaproveitar essa função, né?!**
383 |
384 | Perceba que quebramos uma função que possuía dois parâmetros
385 | em outras duas funções que recebem apenas um parâmetro cada.
386 |
387 |
388 |
389 |
390 | > **Sabe o porquê?**
391 |
392 |
393 |
394 |
395 | *ps: Utilizei `o porquê` junto e com acento pois nesse caso ele*
396 | *tem a função de substantivo, sinônimo de motivo, razão, causa
*
397 | *e sempre deve vir acompanhado do artigo `o`.*
398 |
399 |
400 |
401 |
402 | E só para corroborar o que eu disse anteriormente leia essa citação:
403 |
404 |
405 |
406 | > "Já que todas as funções esperando mais de um argumento podem
407 | > ser transformadas em funções equivalentes recebendo uma única entrada
408 | > (via Currying), o lambda cálculo não tem interesse em criar funções
409 | > que aceitam mais de um argumento..."
410 |
411 |
412 |
413 |
414 | > **Você já tinha imaginado quebrar uma função tão simples como a soma em duas?**
415 |
416 | > Eu, como AMO a Matemática, adoro de trabalhar dessa forma.
417 |
418 |
419 |
420 |
421 |
422 | > **Então agora vamos escrever essa mesma função usando apenas a soma!**
423 |
424 |
425 |
426 |
427 | Para isso precisamos entender o **algoritmo** da multiplicação:
428 |
429 | ```
430 |
431 | Receba x e y
432 | Pegue o valor de x e some ele mesmo y vezes.
433 |
434 |
435 | ```
436 |
437 |
438 |
439 | Traduzindo para JavaScript:
440 |
441 |
442 |
443 |
444 | ```js
445 |
446 | const times = ( y ) => ( x ) => {
447 |
448 | let result = 0
449 |
450 | while ( y > 0 ) { // ( y )
451 | result += x
452 | y--
453 | }
454 |
455 | return result
456 | }
457 |
458 | console.log('3 times 4: ', times( 4 )( 3 ) ) // 3 times 4:
459 |
460 | ```
461 |
462 | #### Reduzindo a multiplicação para a soma
463 |
464 | ```js
465 |
466 | const sum = ( y ) => ( x ) => x + y
467 |
468 | const times = ( y ) => ( x ) => {
469 |
470 | let result = 0
471 |
472 | const sumX = sum( result )
473 |
474 | while ( y > 0 ) { // ( y )
475 | result += sumX( x )
476 | y--
477 | }
478 |
479 | return result
480 | }
481 |
482 | console.log('3 times 4', times( 4 )( 3 ) )
483 |
484 | ```
485 |
486 |
487 |
488 |
489 | > **Conseguiu entender o [`while`](http://mdn.io/while)?**
490 |
491 |
492 |
493 |
494 | Ele é uma função de *looping* assim como o [`for`]() e o [`do while`], porém
495 | é diferente de funções iteradoras como:
496 |
497 | - [map](http://mdn.io/map);
498 | - [filter](http://mdn.io/filter);
499 | - [reduce](http://mdn.io/reduce);
500 | - [forEach](http://mdn.io/forof);
501 | - [for in](http://mdn.io/forin);
502 | - [for of](http://mdn.io/forof);
503 | - etc
504 |
505 | A diferença entre esses dois tipos de funções é que as funções de
506 | *looping* não precisam de uma estrutura de dados como base para iterar.
507 | Já as de iteração necessitam de uma estrutura iterável.
508 |
509 |
510 |
511 |
512 |
513 | ###### Oozaru
514 |
515 | 
516 |
517 | Como demonstrei anterioremente, utilizamos funções anônimas,
518 | que definimos em constantes, pois isso nos remete às Expressões Lambdas
519 | que são a base da Programação Funcional.
520 |
521 | > "Como os nomes de funções são uma mera conveniência, o lambda cálculo
522 | > não tem interesse em nomear uma função."
523 |
524 | *fonte: [O lambda cálculo - Wikipedia](https://pt.wikipedia.org/wiki/C%C3%A1lculo_lambda)*
525 |
526 | Logo preciso também lhe mostrar do outro jeito, usando `function`.
527 |
528 | > Por isso a `function` está na seção ***Oozaru***! Pois você pode
529 | > usar mas **EU** não lhe aconselho.
530 |
531 |
532 |
533 |
534 |
535 | Utilizando nosso último exemplo podemos escrever assim:
536 |
537 |
538 | ```js
539 |
540 | function sum ( y ) {
541 | return function ( x ) {
542 | return x + y
543 | }
544 | }
545 |
546 | function times ( y ) {
547 | return function ( x ) {
548 | let result = 0
549 |
550 | const sumX = sum( result )
551 |
552 | while ( y > 0 ) { // ( y )
553 | result += sumX( x )
554 | y--
555 | }
556 |
557 | return result
558 | }
559 | }
560 |
561 | console.log('3 times 4', times( 4 )( 3 ) )
562 |
563 | ```
564 |
565 |
566 |
567 | Esse tipo de função acima é conhecida como **nomeada**, pois você
568 | definiu um nome diretamente para ela, mas nós também podemos escrever
569 | como se elas fossem funções anônimas desse jeito:
570 |
571 | ```js
572 |
573 | const sum = function ( y ) {
574 | return function ( x ) {
575 | return x + y
576 | }
577 | }
578 |
579 | const times = function ( y ) {
580 | return function ( x ) {
581 | let result = 0
582 |
583 | const sumX = sum( result )
584 |
585 | while ( y > 0 ) { // ( y )
586 | result += sumX( x )
587 | y--
588 | }
589 |
590 | return result
591 | }
592 | }
593 |
594 | console.log('3 times 4', times( 4 )( 3 ) )
595 |
596 | ```
597 |
598 |
599 |
600 | > **Ficou MUITOOOO maior nosso código, né?!**
601 |
602 |
603 |
604 |
605 | ## Exercícios
606 |
607 | 1) Demonstre, como visto nessa aula, a regra de sinais para a operação de divisão.
608 | Cobrindo os 3 casos explicados anteriormente.
609 |
610 | 2) Crie a função de dividir baseando-se no **SEU** algoritmo.
611 |
--------------------------------------------------------------------------------
/Super Sayajin I/Modulo 01/aula01/src/add.subtract.js:
--------------------------------------------------------------------------------
1 | const f = ( x ) => x
2 | const inverse = ( x ) => x * -1
3 |
4 | const add = ( y ) => ( x ) => x + y
5 | const subtract = ( y ) => ( x ) => add( inverse( y ) )( x )
6 |
7 | console.log( add( 4 )( 6 ) )
8 | console.log( subtract( 4 )( 6 ) )
9 |
10 | // const PA = ( y ) => ( x ) => x + y
11 | // const PG = ( y ) => ( x ) => x * y
12 |
13 | // const PA_razao2 = PA( 2 ) // ( x ) => x + 2
14 | // const PA_razao5 = PA( 5 ) // ( x ) => x + 5
15 |
16 | // console.log( PA_razao2( 5 ) )
17 | // console.log( PA_razao5( 5 ) )
18 |
--------------------------------------------------------------------------------
/Super Sayajin I/Modulo 01/aula01/src/deny.js:
--------------------------------------------------------------------------------
1 | const f = ( x ) => x
2 | const inverse = ( x ) => x * -1
3 |
4 | const add = ( x, y ) => x + y
5 | const subtract = ( x, y ) => add( x, inverse( y ) )
6 |
7 | console.log( add( 6, 4 ) )
8 | console.log( subtract( 6, 4 ) )
--------------------------------------------------------------------------------
/Super Sayajin I/Modulo 01/aula01/src/exponenciacao.js:
--------------------------------------------------------------------------------
1 | const pow = ( y ) => ( x ) =>
2 | Math.pow( x, y )
3 |
4 | module.exports = pow
5 |
6 | // const pow = ( x, y ) => Math.pow( x, y )
7 |
8 | // const elevadoAoQuadrado = pow( 2 )
9 | // const elevadoAoCúbo = pow( 3 )
10 | // const elevadoÀDécima = pow( 10 )
11 |
12 | // const num2 = 4
13 | // const num3 = 3
14 | // const num10 = 2
15 |
16 | // console.log( `\n ${num2} AO QUADRADO é :`, elevadoAoQuadrado( num2 ) )
17 | // console.log( `\n ${num3} AO CUBO é :`, elevadoAoCúbo( num3 ) )
18 | // console.log( `\n ${num10} À DÉCIMA POTÊNCIA é :`, elevadoÀDécima( num10 ) )
19 |
20 | /**
21 |
22 | Perceba que as palavras `elevadoÀDécima` possui crase!
23 |
24 | Podemos facilmente entender essa regra de Português pois antes
25 | temos as seguintes palavras: `elevadoAoQuadrado` e `elevadoAoCúbo`;
26 |
27 | Notou que `AoCubo` e `AoQuadrado` possuem a junção de dois artigos??
28 |
29 | Sim! Primeiramente o artigo `a`, pois ele vem da conjungação do verbo
30 | `elevar`, porque quando você eleva, você eleva ALGO.
31 |
32 | Logo você diz: Vou elevar 3 a alguma potência.
33 |
34 | Então se a sequência dessa oração é um substantivo masculino, ele
35 | deve ser precedido do artigo `o`, por isso temos: `Ao`.
36 |
37 | No entanto, se o substantivo for FEMININO, trocamos o artigo `o` pelo
38 | artigo `a`, com isso teremos a junção de 2 artigos `a`.
39 |
40 | E na língua portuguesa isso denota o uso da crase, logo fica: `Á`
41 |
42 | Simples né??
43 |
44 | */
--------------------------------------------------------------------------------
/Super Sayajin I/Modulo 01/aula01/src/exponenciacao.simples.js:
--------------------------------------------------------------------------------
1 | const pow = ( x, y ) => Math.pow( x, y )
2 |
3 | const num2 = 4
4 | const num3 = 3
5 | const num10 = 2
6 |
7 | console.log( `\n ${num2} AO QUADRADO é :`, pow( num2, 2 ) )
8 | console.log( `\n ${num3} AO CUBO é :`, pow( num3, 3 ) )
9 | console.log( `\n ${num10} À DÉCIMA POTÊNCIA é :`, pow( num10, 10 ) )
--------------------------------------------------------------------------------
/Super Sayajin I/Modulo 01/aula01/src/isParisImpar.js:
--------------------------------------------------------------------------------
1 | const isEven = ( x ) => ( ( x % 2 ) === 0 )
2 |
3 | const isOdd = ( x ) => ( ( x % 2 ) !== 0 )
4 |
5 | const conjuntoDeEntrada = [ 0, 1, 2, 3, 4, 5, 6, 7 ]
6 |
7 | const conjuntoDeSaidaPar = conjuntoDeEntrada.filter( isEven )
8 |
9 | const conjuntoDeSaidaImpar = conjuntoDeEntrada.filter( isOdd )
10 |
11 | console.log( 'conjuntoDeSaidaPar: ', conjuntoDeSaidaPar )
12 |
13 | console.log( 'conjuntoDeSaidaImpar: ', conjuntoDeSaidaImpar )
--------------------------------------------------------------------------------
/Super Sayajin I/Modulo 01/aula01/src/media.while.js:
--------------------------------------------------------------------------------
1 |
2 | const workers = [ 1000, 4000 , 10000 ]
3 |
4 | const withdraw = ( list, percent ) => {
5 |
6 | let counter = 0
7 | let newList = []
8 | let media = 0
9 |
10 | while ( counter < list.length) {
11 | const percentValue = list[ counter ] * ( percent / 100 )
12 | const newSalary = list[ counter ] - percentValue
13 |
14 | newList[ counter ] = newSalary
15 | media += newSalary
16 | counter++
17 | }
18 |
19 | return media / list.length
20 | }
21 |
22 | console.log( 'Media of Salaries: ', withdraw( workers, 10 ) )
--------------------------------------------------------------------------------
/Super Sayajin I/Modulo 01/aula01/src/multiply.js:
--------------------------------------------------------------------------------
1 | const inverse = ( x ) => x * -1
2 |
3 | const add = ( y ) => ( x ) => x + y
4 | const subtract = ( y ) => ( x ) => add( inverse( y ) )( x )
5 |
6 | const multiply = ( y ) => ( x ) => {
7 | // const multiply = ( x, y ) => {
8 |
9 | let result = 0
10 |
11 | const addX = add( x )
12 | const decrement1 = subtract( 1 )
13 |
14 | while ( y > 0 ) {
15 | result = addX( result )
16 | y = decrement1( y )
17 | }
18 |
19 | return result
20 | }
21 |
22 | // console.log('3 x 4 =', multiply( 3, 4 ) )
23 | console.log('3 x 4 =', multiply( 4 )( 3 ) )
--------------------------------------------------------------------------------
/Super Sayajin I/Modulo 01/aula01/src/percent.while.js:
--------------------------------------------------------------------------------
1 | const workers = [ 1000, 2500 , 10000 ]
2 |
3 | const withdraw = ( list, percent ) => {
4 |
5 | let counter = 0
6 | let newList = []
7 |
8 | while ( counter < list.length) {
9 | const percentValue = list[ counter ] * ( percent / 100 )
10 | const newSalary = list[ counter ] - percentValue
11 |
12 | newList[ counter ] = newSalary
13 | counter++
14 | }
15 |
16 | return newList
17 | }
18 |
19 | console.log( 'New Salaries: ', withdraw( workers, 10 ) )
--------------------------------------------------------------------------------
/Super Sayajin I/Modulo 01/aula01/src/radiciacao.js:
--------------------------------------------------------------------------------
1 | const pow = require('./exponenciacao')
2 |
3 | const root = ( y ) => ( x ) =>
4 | pow( 1 / y )( x )
5 |
6 |
7 | // module.exports = root
8 |
9 |
10 | const raizQuadrada = root( 2 )
11 | const raizCúbica = root( 3 )
12 | const raiz10De = root( 10 )
13 |
14 | const num2 = 16
15 | const num3 = 27
16 | const num10 = 1024
17 |
18 | console.log( `\n Raiz quadrada de ${num2} é:`, raizQuadrada( num2 ) )
19 | console.log( `\n Raiz cúbica de ${num3} é:`, raizCúbica( num3 ) )
20 | console.log( `\n Raiz décima de ${num10} é:`, raiz10De( num10 ) )
--------------------------------------------------------------------------------
/Super Sayajin I/Modulo 01/aula01/src/raizes.js:
--------------------------------------------------------------------------------
1 | const raiz = require( './radiciacao' )
2 |
3 | const raizQuadradaDe = raiz( 2 )
4 | const raizCúbicaDe = raiz( 3 )
5 | const raizdeÍndice4De = raiz( 4 )
6 | const raizdeÍndice10De = raiz( 10 )
7 |
8 | const num2 = 4
9 | const num3 = 27
10 | const num4 = 1296
11 | const num10 = 1024
12 |
13 | console.log( `\n Raiz Quadrada de ${num2} é :`, raizQuadradaDe( num2 ) )
14 | console.log( `\n Raiz Cúbica De ${num3} é :`, raizCúbicaDe( num3 ) )
15 | console.log( `\n Raiz Quadrada de ${num4} é :`, raizdeÍndice4De( num4 ) )
16 | console.log( `\n Raiz Quadrada de ${num10} é :`, raizdeÍndice10De( num10 ) )
--------------------------------------------------------------------------------
/Super Sayajin I/Modulo 01/aula01/src/soma.negativo.js:
--------------------------------------------------------------------------------
1 | /**
2 | 5-4=1
3 | 5+4=9
4 | 5+(-4)=1
5 | */
6 |
7 | console.log( 5 - 4)
8 | console.log( 5 + 4 )
9 | console.log( 5 + (-4) )
--------------------------------------------------------------------------------
/Super Sayajin I/Modulo 01/aula01/src/sum.while.js:
--------------------------------------------------------------------------------
1 | const workers = [ 1000, 2500 , 10000 ]
2 |
3 | const sumAll = ( list, percent ) => {
4 |
5 | let counter = 0
6 | let total = 0
7 |
8 | while ( counter < list.length) {
9 | const percentValue = list[ counter ] * ( percent / 100 )
10 | const newSalary = list[ counter ] - percentValue
11 |
12 | total += newSalary
13 | counter++
14 | }
15 |
16 | return total
17 | }
18 |
19 | console.log( 'Sum of Salaries: ', sumAll( workers, 10 ) )
--------------------------------------------------------------------------------
/Super Sayajin I/Modulo 01/aula01/src/times.oozaru.const.js:
--------------------------------------------------------------------------------
1 | const sum = function ( y ) {
2 | return function ( x ) {
3 | return x + y
4 | }
5 | }
6 |
7 | const times = function ( y ) {
8 | return function ( x ) {
9 | let result = 0
10 |
11 | const sumX = sum( result )
12 |
13 | while ( y > 0 ) { // ( y )
14 | result += sumX( x )
15 | y--
16 | }
17 |
18 | return result
19 | }
20 | }
21 |
22 | console.log('3 times 4', times( 4 )( 3 ) )
--------------------------------------------------------------------------------
/Super Sayajin I/Modulo 01/aula01/src/times.oozaru.js:
--------------------------------------------------------------------------------
1 | function sum ( y ) {
2 | return function ( x ) {
3 | return x + y
4 | }
5 | }
6 |
7 | function times ( y ) {
8 | return function ( x ) {
9 | let result = 0
10 |
11 | const sumX = sum( result )
12 |
13 | while ( y > 0 ) { // ( y )
14 | result += sumX( x )
15 | y--
16 | }
17 |
18 | return result
19 | }
20 | }
21 |
22 | console.log('3 times 4', times( 4 )( 3 ) )
--------------------------------------------------------------------------------
/Super Sayajin I/Modulo 01/aula01/src/times.reusable.js:
--------------------------------------------------------------------------------
1 | const times = ( y ) => ( x ) => x * y
2 |
3 | const double = times( 2 )
4 | const triple = times( 3 )
5 | const tenTimes = times( 10 )
6 |
7 | const doubleResult = double( 5 )
8 | const tripleResult = triple( 5 )
9 | const tenTimesResult = tenTimes( 5 )
10 |
11 | console.log( 'doubleResult', doubleResult )
12 | console.log( 'tripleResult', tripleResult )
13 | console.log( 'tenTimesResult', tenTimesResult )
--------------------------------------------------------------------------------
/Super Sayajin I/Modulo 01/aula01/src/times.with.sum.js:
--------------------------------------------------------------------------------
1 |
2 | const sum = ( y ) => ( x ) => x + y
3 |
4 | const times = ( y ) => ( x ) => {
5 |
6 | let result = 0
7 |
8 | const sumX = sum( result )
9 |
10 | while ( y > 0 ) { // ( y )
11 | result += sumX( x )
12 | y--
13 | }
14 |
15 | return result
16 | }
17 |
18 | console.log('3 times 4', times( 4 )( 3 ) )
--------------------------------------------------------------------------------
/Super Sayajin I/Modulo 01/aula01/src/times01.js:
--------------------------------------------------------------------------------
1 | const times = ( y ) => ( x ) => {
2 |
3 | let result = 0
4 |
5 | while ( y > 0 ) { // ( y )
6 | result = x + result
7 | y = y - 1
8 | }
9 |
10 | return result
11 | }
12 |
13 | console.log('3 times 4: ', times( 4 )( 3 ) ) // 3 times 4:
--------------------------------------------------------------------------------
/Super Sayajin I/Modulo 01/aula02/README.md:
--------------------------------------------------------------------------------
1 | # Aula 2 - Utilizando nossas operações
2 |
3 |
4 |
5 |
6 | ## Desafio
7 |
8 | Criar a função de divisão utilizando apenas a função de soma,
9 | onde ela receba 2 valores inteiros e consiga retornar um
10 | valor decimal. Por exemplo: `5 / 2 = 2.5`
11 |
12 | Além disso explique como dois valores do conjunto dos Números Naturais
13 | transformou-se em um valor que não está contido nesse grupo e qual o grupo que ele pertence.
14 |
15 | > **Lembrando que a ÚNICA função aceita dentro da divisão será a da soma!**
16 |
17 |
18 | ## Exponenciação e Radiciação
19 |
20 | 
21 |
22 | Como você já deve saber a exponenciação é a função inversa da radiciação
23 | e vice-versa e as derivam da multiplicação e divisão.
24 |
25 | Então vamos parar de enrolar e criar nossa função de exponenciação (`pow`).
26 |
27 |
28 | ```js
29 | const pow = ( y ) => ( x ) =>
30 | Math.pow( x, y )
31 | ```
32 |
33 | Claramente você percebeu que estamos usando a função [`Math.pow`](http://mdn.io/pow),
34 | que é nativa do JavaScript, caso queira saber mais *click* no *link* acima.
35 |
36 | Nesse caso nossa função `pow` recebe primeiramente seu expoente `y` e depois
37 | sua base `x`
38 |
39 |
40 |
41 | ## Aplicação
42 |
43 | Imagine que temos um *Array* de Objetos e precisamos antes de somar
44 | os salários retirar 10% do valor de cada um e depois fazer uma média.
45 |
46 | ```js
47 |
48 | const workers = [ 1000, 2500 , 10000 ]
49 |
50 | const withdraw = ( list, percent ) => {
51 |
52 | let counter = 0
53 | let newList = []
54 |
55 | while ( counter < list.length) {
56 | const percentValue = list[ counter ] * ( percent / 100 )
57 | const newSalary = list[ counter ] - percentValue
58 |
59 | newList[ counter ] = newSalary
60 | counter++
61 | }
62 |
63 | return newList
64 | }
65 |
66 | console.log( 'New Salaries: ', withdraw( workers, 10 ) )
67 |
68 | ```
69 |
70 | No código acima nós apenas criamos um *Array* novo com os valores
71 | dos valores calculados pela nossa função
72 |
73 | ```js
74 |
75 | const workers = [ 1000, 2500 , 10000 ]
76 |
77 | const sumAll = ( list, percent ) => {
78 |
79 | let counter = 0
80 | let total = 0
81 |
82 | while ( counter < list.length) {
83 | const percentValue = list[ counter ] * ( percent / 100 )
84 | const newSalary = list[ counter ] - percentValue
85 |
86 | total += newSalary
87 | counter++
88 | }
89 |
90 | return total
91 | }
92 |
93 | console.log( 'Sum of Salaries: ', sumAll( workers, 10 ) )
94 |
95 | ```
96 |
97 | ### Lembrete 1
98 |
99 | > Percebeu que não criamos **funções** porém não criamos nenhuma constante
100 | > para os valores que passaremos como parâmetro?
101 |
102 | Isso se deve graças a dois conceitos que são obrigatórios para uma linguagem
estar contida no Paradigma Funcional:
103 |
104 | - [First-class Function]()
105 | - [High-Order Function]()
106 |
107 | **Falarei melhor sobre esses conceitos na próxima aula!**
--------------------------------------------------------------------------------
/Super Sayajin I/README.md:
--------------------------------------------------------------------------------
1 | 
2 |
3 |
4 | # Super Sayajin I
5 |
6 |
7 |
8 |
9 |
10 | ## Módulo 1 - Funções e Lógica
11 |
12 | Nesse módulo ensinarei como você irá traduzir seu conhecimento prévio,
13 | principalmente em Matemática do Ensino Médio, em JavaScript Funcional.
14 |
15 | Esse módulo É **OBRIGATÓRIO** para quem:
16 |
17 | - Não saiba a definição de função e/ou conjunto;
18 | - Não sabe como compor operações matemáticas complexas usando apenas soma e números negativos;
19 | - Não tem lógica matemática forte
20 |
21 |
22 | ### Conteúdo
23 |
24 | #### Matemática Discreta
25 |
26 | Vamos aprender como criar TODAS as operações mais utilizadas na Matemática
27 | e como trabalhar com o tipo `Number`, para isso inciaremos direto na função,
28 | para que o aluno entenda que esse é o conceito mais importante que ele precisa.
29 |
30 | As primeiras funções irão utilizar os números passados por parâmetro para que ele
31 | não precise iniciar nenhuma constante que não seja a função, só depois disso que você
32 | aprenderá a trabalhar com o tipo `Number`, encapsulando e usando suas principais funções.
33 |
34 | Depois iremos aprender a parte de coleções de números e conjuntos, onde emularemos
35 | o conceito de conjutos com `Array` e `Set`, pois o `Set` não possui NENHUMA das operações
36 | de conjuntos, como: adição, subtração e intersecção.
37 |
38 | ##### Conceitos
39 |
40 | - Constante;
41 | - nada de `var` **aqui!**
42 | - Função;
43 | - sempre pura!
44 | - Números;
45 | - Operações matemáticas:
46 | - soma, subtração, multiplicação, divisão, exponenciação e radiciação;
47 | - todas baseadas apenas na soma;
48 | - Boolean;
49 | - Lógica: matemática e booleana;
50 | - Conjuntos;
51 | - Operaçes com Conjuntos;
52 | - Física: como inferir fórmulas baseando-se em conceitos.
53 |
54 | ##### JavaScript
55 |
56 | - `while`/`for`;
57 | - `Function`;
58 | - `Number`;
59 | - `Array`;
60 | - `Set`.
61 |
62 | #### Pré-requisitos
63 |
64 | - Ensino Médio (cursando ou completo)
65 | - Não ter medo da Matemática pq ela é uma LINDA!
66 |
67 | #### Artigo
68 |
69 | Sim além dos exercícios que serão passados em cada aula ainda teremos **pelo menos**
70 | um artigo sobre algum dos temas abordados.
71 |
72 |
73 | #### Projeto Final
74 |
75 | Criação de uma calculadora com o máximo possível de funções matemáticas e físicas, cada aluno
76 | deverá criar pelo menos 2 funções novas.
77 |
78 |
79 |
80 |
81 |
82 |
83 |
84 |
85 |
86 | #### Módulo 2 - Estatística & Estrutura de Dados
87 | ##### Super Saiyajin Dai Ni Dankai (第2形態)
88 |
89 | Nesse módulo mostrarei como criar funções de Estatística baseando-se apenas
90 | na sua explicação e porque a estatística é a base para se usar as Redes Neurais
91 | e muito provavelmente no futuro a programação seja mais probabilística do que determinística.
92 |
93 | Com isso você aprenderá a organizar seus dados e retirar informações em cima de um conjunto
94 | de dados numéricos.
95 |
96 | ###### Objetivo
97 |
98 | Construir uma calculadora, via API, com a maiorias das funções de Matemática Estatística utilizadas
99 | pela Inteligência Artificial para que não precisemos depender do *Python* ou *R* para isso.
100 |
101 | ##### Conceitos
102 |
103 | - Recursividade;
104 | - Métodos de Matriz;
105 | - Média;
106 | - Moda;
107 | - Desvio Padrão;
108 | - Como inferir fórmulas baseando-se em conceitos;
109 | - Organização e estruturação dos dados;
110 | - etc.
111 |
112 | ##### Química
113 |
114 | - Estruturação dos dados dos átomos;
115 | - Estruturação dos dados das moléculas;
116 | - Reações Químicas Inorgânicas: síntese e decomposição;
117 | - Distribuição Eletrônica;
118 | - Balanceamento de Reações;
119 | - Cálculo de Lei de Hess.
120 |
121 | ##### JavaScript
122 |
123 | - `let`;
124 | - `map`/`filter`/`reduce`/`concat`/etc;
125 | - `Object`;
126 | - `Math`;
127 | - `Symbol`.
128 |
129 | ##### Projeto Final
130 |
131 |
132 | [Uma Tabela Periódica diferente utilizando-se UX e API](https://github.com/Webschool-io/Elementos-Quimica).
133 |
134 |
135 |
136 |
137 |
138 |
139 |
140 |
141 | #### Módulo 3 - Biologia e Arquitetura de API
142 | ##### Super Saiyajin Dai San Dankai (超サイヤ人第3段階)
143 |
144 |
145 | ##### Pré-requisitos
146 |
147 | - Conclusão do Módulo 2
148 |
149 | ##### Biologia
150 |
151 | ##### JavaScript
152 |
153 | ##### Projeto Final
154 |
155 |
156 |
157 |
158 |
159 |
160 |
161 |
162 |
163 |
164 |
165 | #### Módulo 4 - O JavaScript nú
166 | ##### Super Saiyajin Full Power (超サイヤ人フルパワ)
167 |
168 | Nesse módulo aprenderemos como o JavaScript funciona por trás das cortinas, tanto
169 | no navegador como no Node.js
170 |
171 | ###### JavaScript
172 |
173 | - Async
174 | - Call Stack
175 | - EventLoop
176 | - Events
177 | - Promises
178 | - Prototype
179 |
180 |
181 |
182 |
183 |
184 |
185 |
186 |
--------------------------------------------------------------------------------
/img/cards.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/suissa/Curso-JavaScript-Super-Sayajin-oficial/dc4ac2b68d2a532ad75480c5129173fbdcd34c6d/img/cards.jpg
--------------------------------------------------------------------------------
/img/ss1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/suissa/Curso-JavaScript-Super-Sayajin-oficial/dc4ac2b68d2a532ad75480c5129173fbdcd34c6d/img/ss1.jpg
--------------------------------------------------------------------------------
/img/ss2.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/suissa/Curso-JavaScript-Super-Sayajin-oficial/dc4ac2b68d2a532ad75480c5129173fbdcd34c6d/img/ss2.jpg
--------------------------------------------------------------------------------
/img/ss3.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/suissa/Curso-JavaScript-Super-Sayajin-oficial/dc4ac2b68d2a532ad75480c5129173fbdcd34c6d/img/ss3.jpg
--------------------------------------------------------------------------------
/img/ss4.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/suissa/Curso-JavaScript-Super-Sayajin-oficial/dc4ac2b68d2a532ad75480c5129173fbdcd34c6d/img/ss4.jpg
--------------------------------------------------------------------------------
/img/ss5.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/suissa/Curso-JavaScript-Super-Sayajin-oficial/dc4ac2b68d2a532ad75480c5129173fbdcd34c6d/img/ss5.jpg
--------------------------------------------------------------------------------