├── .gitignore
├── README.md
├── matrix-multiply
├── README.md
└── suissa
│ ├── README.md
│ ├── desafio.jpg
│ ├── matrix.multiply.js
│ └── matrix.multiply.spec.js
├── only-nine
├── index.js
└── readme.md
├── operators
├── README.md
└── suissa
│ ├── README.md
│ ├── index.functional.js
│ ├── index.js
│ ├── operators.js
│ └── operators.spec.js
├── package.json
├── peculiaridades_matematicas
├── desafio.jpg
├── index.js
└── readme.md
└── show-me-evens-odds
├── readme.md
└── suissa
└── index.js
/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_Store
2 | node_modules/
3 | */node_modules/
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # JavaScript - Desafios
2 |
3 | > Repositório para centralizar os desafios de JS dos grupos de [Node.js](https://t.me/NodejsBR), [JavaScript](https://t.me/javascriptbrasil) e [JS4Girls](https://t.me/joinchat/AAAAAAv6M1fbEYWkmYFbSg)
4 |
5 | Dia ou outro alguém joga algum desafio la ou pede uma ajuda e isso gera algumas soluções que decedi guardar por
6 | aqui para ajudar nossos alunos.
7 |
8 | ## Como propor um desafio
9 |
10 | 1. Fork esse repositório.
11 | 2. Adicione seu desafio na lista abaixo.
12 | 3. Faça um pull request.
13 |
14 |
15 | ## Desafios
16 |
17 | - [Dobrar valores pares da matriz](https://gist.github.com/anabastos/4014c329a0852b7aa9062606e210a9ab).
18 | - [Somatório de Valores em Objetos](https://gist.github.com/anabastos/fbdfef7fcc64105e76e5e26218ebf7e6).
19 | - [Mostre-me os pares - Mostre-me os ímpares](https://gist.github.com/yesroh/720cda408bbc899fc6c69bfddfbe6505).
20 | - [Números Primos](https://gist.github.com/Woodsphreaker/e81e068caee110e821c4c9b375a76ddd).
21 | - [Conte os Números Negativos em uma Matriz](https://gist.github.com/yesroh/560fe5e74638292199c7c3cd05716be8).
22 | - [Desafio dos operadores básicos](https://github.com/Webschool-io/js-desafios/tree/master/operators/suissa)
23 | - [Desafio - Multiplicar Matrizes](https://github.com/Webschool-io/js-desafios/tree/master/matrix-multiply/suissa)
24 |
25 |
--------------------------------------------------------------------------------
/matrix-multiply/README.md:
--------------------------------------------------------------------------------
1 | # Desafio - Multiplicar Matrizes
2 |
3 | 
4 |
5 |
6 | ## Analisando
7 |
8 | Como podemos perceber para calcularmos 1 valor da matriz final precisamos:
9 |
10 | - pegar a linha da primeira
11 | - pegar a coluna da segunda
12 | - multiplicar o primeiro da linha pelo primeiro da coluna e assim por diante
13 | - somar o valor resultante de cada par (linha, coluna)
14 | - colocar esse valor no seu lugar coreto
15 |
16 | ## Funcional Way
17 |
18 |
19 | ## Testando
20 |
21 |
22 |
23 | ## Modularizando
24 |
25 |
26 |
27 |
--------------------------------------------------------------------------------
/matrix-multiply/suissa/README.md:
--------------------------------------------------------------------------------
1 | # Desafio - Multiplicar Matrizes
2 |
3 |
4 | 
5 |
6 |
7 | ## Analisando
8 |
9 | Como podemos perceber para calcularmos 1 valor da matriz final precisamos:
10 |
11 | - pegar a linha da primeira
12 | - pegar a coluna da segunda
13 | - multiplicar o primeiro da linha pelo primeiro da coluna e assim por diante
14 | - somar o valor resultante de cada par (linha, coluna)
15 | - colocar esse valor no seu lugar coreto
16 |
17 | Logo possuímos os seguintes macro-problemas para solucionar:
18 |
19 | - pegar os valores e calcular
20 | - colocar no seu lugar correto
21 |
22 | ### Estrutura de Dados
23 |
24 | Vamos entender como criamos e acessamos *arrays* no JS, inicialmente vamos cria-las, sendo a `matriz1` uma matriz 2x3 (2 linhas e 3 colunas) e a `matriz2` uma matriz 3x2 (3 linhas e 2 colunas):
25 |
26 | ```js
27 |
28 | const matriz1 = [
29 | [ 1, 2, 3 ],
30 | [ 4, 5, 6 ]
31 | ]
32 |
33 | const matriz2 = [
34 | [ 7, 8 ],
35 | [ 9, 10 ],
36 | [ 11, 12 ]
37 | ]
38 |
39 | ```
40 |
41 | > Percebeu que precisamos separar cada linha em um *array*?
42 | > Pois é dessa forma que criamos *arrays* multi-dimensionais com JS.
43 |
44 | Agora vamos analisar a matriz final, ela é uma matriz 2x2:
45 |
46 | ```js
47 |
48 | const matrizResult = [
49 | [ 58, 64 ],
50 | [ 139, 154 ]
51 | ]
52 |
53 | ```
54 |
55 | > **Por quê?**
56 |
57 | > Quando multiplicamos uma matriz por outra, é necessário que o número de colunas da primeira matriz seja igual ao número de linhas da segunda matriz. O resultado dessa multiplicação será uma matriz com o número de linhas da primeira e o número de colunas da segunda.
58 |
59 | *fonte: [Multiplicação de Matrizes](http://mundoeducacao.bol.uol.com.br/matematica/multiplicacao-matrizes.htm)*
60 |
61 |
62 | Guarde bem, isso: **O resultado dessa multiplicação será uma matriz com o número de linhas da primeira e o número de colunas da segunda.** Usaremos logo logo.
63 |
64 | ### Verificar o tamanho das matrizes
65 |
66 | Para isso criaremos 3 funções:
67 |
68 | - conteColunas: Number
69 | - conteLinhas: Number
70 | - possoMultiplicar: Boolean
71 |
72 | Dessa forma:
73 |
74 | ```
75 |
76 | const conteColunas = ( matriz ) => matriz[ 0 ].length
77 |
78 | const conteLinhas = ( matriz ) =>
79 | matriz.filter( linha => Array.isArray( linha ) ).length
80 |
81 | const possoMultiplicar = ( m1, m2 ) =>
82 | conteColunas( m1 ) === conteLinhas( m2 )
83 |
84 | console.log(`possoMultiplicar: `, possoMultiplicar( matriz1, matriz2 )
85 | //true
86 |
87 | ```
88 |
89 |
90 | **A malandragem se encontra nessa parte: `const conteLinhas = ( matriz ) =>
91 | matriz.filter( linha => Array.isArray( linha ) ).length`.**
92 |
93 | Pois como precisamos passar em todas suas linhas para conta-las utilizei o `filter` na `matriz` testando se cada `linha` é um Array, caso seja a linha é apenas retornada pelo `filter` e quando finaliza toda a iteração eu apenas conto quantas linhas foram retornadas com o `length` e pronto!
94 |
95 |
96 |
97 | ### Pegar os valores e calcular
98 |
99 | Primeiramente precisamos pegar os valores da primeira linha da primeira matriz e da primeira coluna da segunda matriz.
100 |
101 | ```js
102 |
103 | const matriz1 = [
104 | [ 1, 2, 3 ],
105 | [ 4, 5, 6 ]
106 | ]
107 |
108 | const matriz2 = [
109 | [ 7, 8 ],
110 | [ 9, 10 ],
111 | [ 11, 12 ]
112 | ]
113 |
114 | const pegueLinha = ( pos, matriz ) => matriz[ pos ]
115 | const pegueColuna = ( pos, matriz ) => matriz.map( ( arr ) => arr[ pos ] )
116 |
117 | const primeiraLinha = getLinha( 0, matriz1 )
118 | const primeiraColuna = getColuna( 0, matriz1 )
119 |
120 | ```
121 |
122 |
123 |
124 | > **Agora que a cobra vai fumar!**
125 |
126 |
127 |
128 | Porque iremos criar a função que calcula um valor:
129 |
130 | ```js
131 |
132 | const multipliqueLinhaColuna = ( linha, coluna ) => {
133 | const result = linha.reduce( ( acc, cur, pos ) => {
134 | acc.push( cur * coluna[pos] )
135 | return acc
136 | }, [] ).reduce( (a, b) => a+b)
137 | return result
138 | }
139 |
140 | ```
141 |
142 | Melhorando ela deixaremos assim:
143 |
144 | ```js
145 |
146 | const somandoTudo = ( a, b ) => a + b
147 |
148 | const multipliquePela = ( coluna ) => ( calculado, valorLinha, pos ) => {
149 | calculado.push( valorLinha * coluna[ pos ] )
150 | return calculado
151 | }
152 |
153 | const multipliqueLinhaColuna = ( linha, coluna ) =>
154 | linha.reduce( multipliquePela( coluna ), [] ).reduce( somandoTudo )
155 |
156 | console.log(multipliqueLinhaColuna( pegueLinha( 0, matriz1 ),
157 | pegueColuna( 0, matriz2 ) ) )
158 | // 58
159 |
160 | ```
161 |
162 |
163 |
164 | Vou explicar como chegamos nesse resultado correto.
165 |
166 |
167 |
168 | Inicialmente vamos analisar a função `multipliqueLinhaColuna`:
169 |
170 | ```js
171 |
172 | const multipliqueLinhaColuna = ( linha, coluna ) =>
173 | linha.reduce( multipliquePela( coluna ), [] ).reduce( somandoTudo )
174 |
175 | multipliqueLinhaColuna( pegueLinha( 0, matriz1 ),
176 | pegueColuna( 0, matriz2 ) )
177 |
178 | ```
179 |
180 | Como seus argumentos estamos passando:
181 |
182 | - pegueLinha( 0, matriz1 ): linha
183 | - pegueColuna( 0, matriz2 ): coluna
184 |
185 | Pois queremos a lista dos valores da linha e coluna da posição `0`, então elas farão esse trabalho para que não precisemos passar manualmente e depois eu começo a reduzir pela linha.
186 |
187 | > **\- Como assim reduzir???**
188 |
189 |
190 | Assim: `linha.reduce( multipliquePela( coluna ), [] )`. Então estamos pegando cada valor da linha e executando a função `multipliquePela( coluna )` e nessa função injetamos a `coluna` que será usada dentro do primeiro `reduce`: `linha.reduce( multipliquePela( coluna ), [] )`.
191 |
192 | ```js
193 |
194 | const somandoTudo = ( a, b ) => a + b
195 |
196 | const multipliquePela = ( coluna ) => ( calculado, valorLinha, pos ) => {
197 | calculado.push( valorLinha * coluna[ pos ] )
198 | return calculado
199 | }
200 |
201 |
202 | ```
203 |
204 | Precisamos injetar a `coluna` pois a nosso `reduce` utilizará a função retornada por `multipliquePela = ( coluna ) =>` que possui a seguinte assinatura `( acc, cur, index )`, entretanto para deixar o código facilmente legível pelos alunos do Ensino Médio coloquei: `( calculado, valorLinha, pos )` onde o `calculado` é o acumulador, o `valorLinha` é o valor atual de cada iteração e `pos`(posição) é o índice da posição atual da iteração.
205 |
206 | Então calculamos com `valorLinha * coluna[ pos ]` pois para cada posição da linha você deve multiplicar com o valor da mesma posição da coluna e depois adicionamos esse resultado no *array* `calculado`, retornado esse *array* pois ele sempre entrará na primeira posição como nosso acumulador `calculado`.
207 |
208 |
209 |
210 | **Sabendo disso podemos ir para o próximo problema!**
211 |
212 |
213 |
214 | ### Colocar no seu lugar correto
215 |
216 | Agora fizemos boa parte do nosso trabalho falta **apenas fazer funcionar para toda a Matriz**!!
217 |
218 |
219 |
220 | > **Apenas, disse ele e saiu correndo.**
221 |
222 |
223 |
224 |
225 | ```js
226 |
227 | const matrizCalculada = ( [ m1, m2 ] = matrizes ) => {
228 |
229 | return m1.map( ( linha, pos ) => {
230 | let contador = 0
231 | let vezes = m1.length
232 | const valores = []
233 | while ( vezes ) {
234 | valores.push( multipliqueLinhaColuna( pegueLinha( pos, m1 ),
235 | pegueColuna( contador, m2 ) ) )
236 | --vezes
237 | ++contador
238 | }
239 | if ( !vezes ) return valores
240 | } )
241 |
242 | }
243 |
244 | console.log( matrizCalculada( [matriz1, matriz2 ]) )
245 | // [ [ 58, 64 ], [ 139, 154 ] ]
246 |
247 | ```
248 |
249 | Logo temos na primeira linha os valores `58` e `63`; e na segunda os valores `139` e `154` como a imagem inicial demonstra.
250 |
251 | > **Muito fácil né?**
252 |
253 | ### Juntando tudo
254 |
255 | ```js
256 |
257 | const matriz1 = [
258 | [ 1, 2, 3 ],
259 | [ 4, 5, 6 ]
260 | ]
261 |
262 | const matriz2 = [
263 | [ 7, 8 ],
264 | [ 9, 10 ],
265 | [ 11, 12 ]
266 | ]
267 |
268 | const matrizResult = [
269 | [ 58, 64 ],
270 | [ 139, 154 ]
271 | ]
272 |
273 | const conteColunas = ( matriz ) => matriz[ 0 ].length
274 | const conteLinhas = ( matriz ) =>
275 | matriz.filter( list => Array.isArray( list ) ).length
276 |
277 | const possoMultiplicar = ( m1, m2 ) =>
278 | conteColunas( m1 ) === conteLinhas( m2 )
279 |
280 | const somandoTudo = ( a, b ) => a + b
281 |
282 | const multipliquePela = ( coluna ) => ( calculado, valorLinha, pos ) => {
283 | calculado.push( valorLinha * coluna[ pos ] )
284 | return calculado
285 | }
286 |
287 | const multipliqueLinhaColuna = ( linha, coluna ) =>
288 | linha.reduce( multipliquePela( coluna ), [] ).reduce( somandoTudo )
289 |
290 | const pegueLinha = ( pos, matriz ) => matriz[ pos ]
291 | const pegueColuna = ( pos, matriz ) => matriz.map( ( arr ) => arr[ pos ] )
292 |
293 |
294 | const matrizCalculada = ( [ m1, m2 ] = matrizes ) => {
295 |
296 | return m1.map( ( linha, pos ) => {
297 | let contador = 0
298 | let vezes = m1.length
299 | const valores = []
300 | while ( vezes ) {
301 | valores.push( multipliqueLinhaColuna( pegueLinha( pos, m1 ),
302 | pegueColuna( contador, m2 ) ) )
303 | --vezes
304 | ++contador
305 | }
306 | if ( !vezes ) return valores
307 | } )
308 |
309 | }
310 |
311 | const resultadoFinal = matrizCalculada( [ matriz1, matriz2 ] )
312 | console.log('resultadoFinal: ', resultadoFinal)
313 | // resultadoFinal: [ [ 58, 64 ], [ 139, 154 ] ]
314 |
315 | ```
316 |
317 |
318 | ## Testando
319 |
320 | Vamos inicialmente criar o teste para calcularmos o primeiro valor:
321 |
322 | ```js
323 |
324 | const assert = require( 'assert' )
325 |
326 | const matriz1 = [
327 | [ 1, 2, 3 ],
328 | [ 4, 5, 6 ]
329 | ]
330 |
331 | const matriz2 = [
332 | [ 7, 8 ],
333 | [ 9, 10 ],
334 | [ 11, 12 ]
335 | ]
336 |
337 | const matrizResult = [
338 | [ 58, 64 ],
339 | [ 139, 154 ]
340 | ]
341 |
342 | const multiplyMatriz = ( linha, coluna ) => {
343 | const result = linha.reduce( ( acc, cur, pos ) => {
344 | acc.push( cur * coluna[pos] )
345 | return acc
346 | }, [] ).reduce( (a, b) => a+b)
347 | return result
348 | }
349 | const getLinha = ( pos, matriz ) => matriz[ pos ]
350 | const getColuna = ( pos, matriz ) => matriz.map( ( arr ) => arr[ pos ] )
351 |
352 | const testOneValue = ( pos, [ m1, m2 ] = matrizes, matrizFinal ) =>
353 | assert.deepEqual( matrizFinal[pos][pos],
354 | multiplyMatriz( getLinha( pos, m1 ),
355 | getColuna( pos, m2 ) )
356 | )
357 |
358 | const specOneValue = {
359 | title: `Testar se o primeiro valor esta correto`,
360 | msgOK: `\n\t Primeiro valor - passou!`,
361 | result: testOneValue( 0, [matriz1, matriz2], matrizResult )
362 | }
363 |
364 | const showTitle = ( msg ) => { console.log(msg); return 1 }
365 |
366 | const runTest = ( spec ) => //console.log('spec', spec)
367 | ( showTitle( spec.title ) && undefined === spec.result )
368 | ? console.log( spec.msgOK )
369 | : console.log( `\n\t FUUUUUUU!` )
370 |
371 |
372 | runTest( specOneValue )
373 |
374 | ```
375 |
376 | ## Funcional Way
377 |
378 | ## Modularizando
379 |
380 |
381 |
382 |
--------------------------------------------------------------------------------
/matrix-multiply/suissa/desafio.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Webschool-io/js-desafios/1f85d026b294cbad34016f6770c1221818e3163b/matrix-multiply/suissa/desafio.jpg
--------------------------------------------------------------------------------
/matrix-multiply/suissa/matrix.multiply.js:
--------------------------------------------------------------------------------
1 | const conteColunas = ( matriz ) => matriz[ 0 ].length
2 | const conteLinhas = ( matriz ) =>
3 | matriz.filter( list => Array.isArray( list ) ).length
4 |
5 | const possoMultiplicar = ( m1, m2 ) =>
6 | conteColunas( m1 ) === conteLinhas( m2 )
7 |
8 | const somandoTudo = ( a, b ) => a + b
9 |
10 | const multipliquePela = ( coluna ) => ( calculado, valorLinha, pos ) => {
11 | calculado.push( valorLinha * coluna[ pos ] )
12 | return calculado
13 | }
14 |
15 | const multipliqueLinhaColuna = ( linha, coluna ) =>
16 | linha.reduce( multipliquePela( coluna ), [] )
17 | .reduce( somandoTudo )
18 |
19 | const pegueLinha = ( pos, matriz ) => matriz[ pos ]
20 | const pegueColuna = ( pos, matriz ) => matriz.map( ( arr ) => arr[ pos ] )
21 |
22 |
23 | const matrizCalculada = ( [ m1, m2 ] = matrizes ) =>
24 | m1.map( ( linha, pos ) => {
25 | let contador = 0
26 | let vezes = m1.length
27 | const valores = []
28 | while ( vezes ) {
29 | valores.push( multipliqueLinhaColuna( pegueLinha( pos, m1 ),
30 | pegueColuna( contador, m2 ) ) )
31 | --vezes
32 | ++contador
33 | }
34 | if ( !vezes ) return valores
35 | } )
36 |
37 | module.exports = ({
38 | matrizCalculada,
39 | multipliqueLinhaColuna,
40 | pegueLinha,
41 | pegueColuna
42 | })
43 |
44 |
--------------------------------------------------------------------------------
/matrix-multiply/suissa/matrix.multiply.spec.js:
--------------------------------------------------------------------------------
1 | const assert = require( 'assert' )
2 |
3 | const matriz1 = [
4 | [ 1, 2, 3 ],
5 | [ 4, 5, 6 ]
6 | ]
7 |
8 | const matriz2 = [
9 | [ 7, 8 ],
10 | [ 9, 10 ],
11 | [ 11, 12 ]
12 | ]
13 |
14 | const matrizResult = [
15 | [ 58, 64 ],
16 | [ 139, 154 ]
17 | ]
18 |
19 | const Matriz = require('./matrix.multiply')
20 | const resultadoFinal = Matriz.matrizCalculada( [ matriz1, matriz2 ] )
21 |
22 | const testeUmValor = ( pos, [ m1, m2 ] = matrizes, matrizFinal ) =>
23 | assert.deepEqual( matrizFinal[pos][pos],
24 | Matriz.multipliqueLinhaColuna(Matriz.pegueLinha( pos, m1 ),
25 | Matriz.pegueColuna( pos, m2 ) )
26 | )
27 |
28 | const testeTodosValores = ([ m1, m2 ] = matrizes, matrizFinal ) => {
29 | matrizFinal.map( (linha, posLinha) =>
30 | linha.map( (valor, posValor) =>
31 | ( matrizFinal[posLinha][posValor] ===
32 | resultadoFinal[posLinha][posValor] )
33 | ? resultadoFinal[posLinha][posValor]
34 | : showError( matrizFinal[posLinha][posValor],
35 | resultadoFinal[posLinha][posValor] )
36 | )
37 | )
38 | }
39 | const specUmValor = {
40 | title: `\n Testar se o primeiro valor esta correto`,
41 | msgOK: `\t Primeiro valor - passou!`,
42 | result: testeUmValor( 0, [matriz1, matriz2], matrizResult )
43 | }
44 |
45 | const specTodosValores = {
46 | title: `\n Testar se todos os valores estão corretos`,
47 | msgOK: `\t Estão todos corretos - parabéns!
48 | \t Esperado: ${matrizResult}
49 | \t Recebido: ${resultadoFinal}
50 | `,
51 | result: testeTodosValores( [matriz1, matriz2], matrizResult )
52 | }
53 |
54 | const showTitle = ( msg ) => { console.log(msg); return 1 }
55 | const showError = ( expected, received ) =>
56 | assert.deepEqual( expected, received )
57 |
58 | const runTests = ( specs ) =>
59 | specs.map( ( spec ) =>
60 | ( showTitle( spec.title ) && undefined === spec.result )
61 | ? console.log( spec.msgOK )
62 | : console.log( `\n\t FUUUUUUU!` )
63 | )
64 |
65 | const specs = [
66 | specUmValor,
67 | specTodosValores
68 | ]
69 |
70 | console.log('\n Matriz 1: ', matriz1)
71 | console.log(' Matriz 2: ', matriz2)
72 | console.log(' Matriz Final: ', matrizResult)
73 | runTests( specs )
74 |
--------------------------------------------------------------------------------
/only-nine/index.js:
--------------------------------------------------------------------------------
1 | const expect = require('chai').expect
2 |
3 | const resultInOne = ( num ) => num / num
4 |
5 | const resolveChallenge = ( num ) => resultInOne( num ) + 99
6 |
7 | describe('Teste se consegue transformar 99 virar 100 usando somente o número 9', () => {
8 |
9 | it('99 virou 100?', () => {
10 | const num = 99
11 | const result = resolveChallenge( num )
12 | expect( result ).to.equal( 100 )
13 | })
14 |
15 | })
--------------------------------------------------------------------------------
/only-nine/readme.md:
--------------------------------------------------------------------------------
1 | # Desafio - Transforme 99 em 100
2 |
3 | Desafio proposto pelo meu aluno [Samuel Verneck](https://github.com/samverneck/).
4 |
5 | > Como posso fazer o 99 virar 100 usando somente o número 9?
6 | >
7 | > Obs: Você pode usar multiplicação, subtração, adição, soma e etc...
8 | >
9 | > **SÓ PODE USAR O NÚMERO NOVE**
10 |
11 |
12 | 
13 |
14 |
15 | Primeira coisa que pensei foi em criar uma equaçao para isso, assim:
16 |
17 | ```
18 |
19 | 99 + fn = 100
20 |
21 | ```
22 |
23 | >
24 | > Por que usar a soma tio Suissa?
25 | >
26 | > \- Simples, porque para sair de 99 e chegar em 100 você
27 | > precisa **"apenas"** somar 1, correto?
28 | >
29 |
30 | Logo precisamos criar uma funçao que utilize apenas 9s e resulte em 1.
31 |
32 | Pense comigo:
33 |
34 | >Se podemos usar a divisao e sabemos que um número dividido por ele mesmo resulta em 1, qual a soluçao mais lógica nesse caso?
35 |
36 |
37 | ```
38 |
39 | 99 + (9/9) = 100
40 |
41 | ```
42 |
43 |
44 |
45 | > **Pronto!**
46 |
47 | # Solution
48 |
49 | ```
50 |
51 | const expect = require('chai').expect
52 |
53 | const resultInOne = ( num ) => num / num
54 |
55 | const resolveChallenge = ( num ) => resultInOne( num ) + 99
56 |
57 | describe('Teste se consegue transformar 99 virar 100 usando somente o número 9', () => {
58 |
59 | it('99 virou 100?', () => {
60 | const num = 99
61 | const result = resolveChallenge( num )
62 | expect( result ).to.equal( 100 )
63 | })
64 |
65 | })
66 |
67 | ```
68 |
--------------------------------------------------------------------------------
/operators/README.md:
--------------------------------------------------------------------------------
1 | # Desafio dos operadores básicos
2 |
3 | Dado o Array matrix, utilizar a primeira posição como indice dos operadores basicos
4 | [2, 4, 6, 8]
5 |
6 | [2] deve multiplicar cada posição [2] * [12, 14, 16, 18] => [24, 28, 32, 36]
7 | [4] deve dividir cada posição [4] / [20, 24, 28, 32] => [5, 6, 7, 8]
8 | [6] deve subtrair cada posição [6] - [32, 34, 36, 38] => [26, 28, 30, 32]
9 | [8] deve somar cada posição [8] + [42, 44, 46, 48] => [50, 52, 54, 56]
10 |
11 | Quando todos os calculos forem feitos, os novos valores do array devem ser somados juntamente com o [2, 4, 6, 8] ou seja:
12 |
13 | soma ([[2, 4, 6, 8], [24, 28, 32, 36], [5, 6, 7, 8], [26, 28, 30, 32], [50, 52, 54, 56]]) = 494
14 |
15 | O resultado final do cálculo é 494
--------------------------------------------------------------------------------
/operators/suissa/README.md:
--------------------------------------------------------------------------------
1 | # Desafio dos operadores básicos
2 |
3 | 
4 |
5 | Dado o Array matrix:
6 |
7 | ```js
8 |
9 | const matrix = [
10 | [2,4,6,8],
11 | [12,14,16,18],
12 | [20,24,28,32],
13 | [32,34,36,38],
14 | [42,44,46,48]
15 | ]
16 |
17 | ```
18 |
19 | Utilizar a primeira posição como índice dos operadores basicos [2, 4, 6, 8]
20 |
21 |
22 | [2] deve multiplicar cada posição [2] * [12, 14, 16, 18] => [24, 28, 32, 36]
23 |
24 | [4] deve dividir cada posição [4] / [20, 24, 28, 32] => [5, 6, 7, 8]
25 |
26 | [6] deve subtrair cada posição [6] - [32, 34, 36, 38] => [26, 28, 30, 32]
27 |
28 | [8] deve somar cada posição [8] + [42, 44, 46, 48] => [50, 52, 54, 56]
29 |
30 | Quando todos os calculos forem feitos, os novos valores do array devem ser somados juntamente com o [2, 4, 6, 8] ou seja:
31 |
32 | soma ([[2, 4, 6, 8], [24, 28, 32, 36], [5, 6, 7, 8], [26, 28, 30, 32], [50, 52, 54, 56]]) = 494
33 |
34 | O resultado final do cálculo é 494
35 |
36 |
37 | ## Analisando
38 |
39 | Temos a seguinte matriz, retirando a dos operadores:
40 |
41 | ```js
42 |
43 | const matrix = [
44 | [12,14,16,18],
45 | [20,24,28,32],
46 | [32,34,36,38],
47 | [42,44,46,48]
48 | ]
49 |
50 | ```
51 |
52 | E colocando cada índice e sua operação ao lado da lista de valores que precisamos executar cada operação fica bem mais facil visualizar o que precisamos fazer:
53 |
54 |
55 | ```js
56 |
57 | const matrix = [
58 | 2 * [12,14,16,18],
59 | 4 / [20,24,28,32],
60 | 6 - [32,34,36,38],
61 | 8 + [42,44,46,48]
62 | ]
63 |
64 | ```
65 | Podemos criar um Objeto correlacionando os indices com as operações a serem executadas, por exemplo:
66 |
67 | ```js
68 |
69 | const multiply = x => y => x * y
70 | const divide = x => y => x * y
71 | const minus = x => y => x - y
72 | const sum = x => y => x + y
73 |
74 | const operators = {
75 | multiply,
76 | divide,
77 | minus,
78 | sum
79 | }
80 |
81 | ```
82 |
83 | > Por que vc acha que fiz dessa forma?
84 |
85 | Vamos reler o que o desafio propõe:
86 |
87 | ```
88 |
89 | [2] deve multiplicar cada posição [2] * [12, 14, 16, 18] => [24, 28, 32, 36]
90 | [4] deve dividir cada posição [4] / [20, 24, 28, 32] => [5, 6, 7, 8]
91 | [6] deve subtrair cada posição [6] - [32, 34, 36, 38] => [26, 28, 30, 32]
92 | [8] deve somar cada posição [8] + [42, 44, 46, 48] => [50, 52, 54, 56]
93 |
94 | ```
95 |
96 | Então podemos traduzir isso em JS assim:
97 |
98 | ```js
99 |
100 | const multiplyBy2 = operators.multiply( 2 )
101 | const resultMultiplyBy2 = matrix[ 0 ].map( multiplyBy2 )
102 |
103 | console.log(`resultMultiplyBy2: ${resultMultiplyBy2}`)
104 | // resultMultiplyBy2: 24,28,32,36
105 |
106 | ```
107 |
108 | E assim por diante, porém podemos melhorar um pouquinho deixando assim:
109 |
110 | ```js
111 |
112 | const multiply = x => y => x * y
113 | const divide = x => y => x * y
114 | const minus = x => y => x - y
115 | const sum = x => y => x + y
116 |
117 | // ops === operators
118 | const ops = {
119 | multiply,
120 | divide,
121 | minus,
122 | sum
123 | }
124 |
125 | const opsValues = [ 2, 4, 6, 8 ]
126 |
127 | const opsFunctions = {
128 | multiply: 0,
129 | divide: 1,
130 | minus: 2,
131 | sum: 3
132 | }
133 |
134 | const matrix = [
135 | [12, 14, 16, 18],
136 | [20, 24, 28, 32],
137 | [32, 34, 36, 38],
138 | [42, 44, 46, 48]
139 | ]
140 |
141 | const multiplyBy2 = ops.multiply( opsValues[ opsFunctions.multiply ] )
142 | const resultMultiplyBy2 = matrix[ opsFunctions.multiply ].map( multiplyBy2 )
143 |
144 | ```
145 |
146 | Percebeu que quando executamos `ops.multiply( opsValues[ opsFunctions.multiply ] )` ela automagicamente pegara' o valor correto para aquela operação, pois basicamente o valor `0` que tínhamos agora foi substituído por `opsFunctions.multiply`.
147 |
148 | Logo com isso acessamos o primeiro valor de `opsValues` para começar a multiplicar a lista.
149 |
150 | Agora vamos finalizar para as outras operações, porém deixando mais genérico, dessa forma:
151 |
152 |
153 | ```js
154 |
155 | const multiply = x => y => y * x
156 | const divide = x => y => y / x
157 | const minus = x => y => y - x
158 | const sum = x => y => y + x
159 |
160 | // ops === operators
161 | const ops = {
162 | multiply,
163 | divide,
164 | minus,
165 | sum
166 | }
167 |
168 | const opsFunctions = {
169 | multiply: 0,
170 | divide: 1,
171 | minus: 2,
172 | sum: 3
173 | }
174 |
175 | const matrixBase = [
176 | [ 2, 4, 6, 8 ],
177 | [12, 14, 16, 18],
178 | [20, 24, 28, 32],
179 | [32, 34, 36, 38],
180 | [42, 44, 46, 48]
181 | ]
182 |
183 | const [ opsValues, ...matrix] = matrixBase
184 |
185 | const multiplyByN = ops.multiply( opsValues[ opsFunctions.multiply ] )
186 | const resultMultiplyByN = matrix[ opsFunctions.multiply ].map( multiplyByN )
187 | console.log(`resultMultiplyByN: ${resultMultiplyByN}`)
188 |
189 | const divideByN = ops.divide( opsValues[ opsFunctions.divide ] )
190 | const resultDivideByN = matrix[ opsFunctions.divide ].map( divideByN )
191 | console.log(`resultDivideByN: ${resultDivideByN}`)
192 |
193 | const minusByN = ops.minus( opsValues[ opsFunctions.minus ] )
194 | const resultMinusByN = matrix[ opsFunctions.minus ].map( minusByN )
195 | console.log(`resultMinusByN: ${resultMinusByN}`)
196 |
197 |
198 | const sumByN = ops.sum( opsValues[ opsFunctions.sum ] )
199 | const resultSumByN = matrix[ opsFunctions.sum ].map( sumByN )
200 | console.log(`resultSumByN: ${resultSumByN}`)
201 |
202 |
203 | /**
204 | resultMultiplyByN: 24,28,32,36
205 | resultDivideByN: 5,6,7,8
206 | resultMinusByN: 26,28,30,32
207 | resultSumByN: 50,52,54,56
208 | */
209 |
210 | ```
211 |
212 | Você deve se perguntar:
213 |
214 | > \- E aquele JS Funcional maroto tio Suissa?
215 | >
216 | > Bora pensar então?
217 |
218 | ## Funcional Way
219 |
220 | ```js
221 |
222 | const multiply = x => y => y * x
223 | const divide = x => y => y / x
224 | const minus = x => y => y - x
225 | const sum = x => y => y + x
226 |
227 | const operators = [
228 | multiply,
229 | divide,
230 | minus,
231 | sum
232 | ]
233 |
234 | const matrixBase = [
235 | [ 2, 4, 6, 8 ],
236 | [12, 14, 16, 18],
237 | [20, 24, 28, 32],
238 | [32, 34, 36, 38],
239 | [42, 44, 46, 48]
240 | ]
241 |
242 | const [ operatorsValues, ...matrix] = matrixBase
243 |
244 | const makeOperation = ( operators, operatorsValues, op ) => ( num ) =>
245 | operators[op]( operatorsValues[op] )(num)
246 |
247 | const calculate = ( operators ) => ( list, op ) =>
248 | list.map( makeOperation( operators, operatorsValues, op ) )
249 |
250 | const calculateMatrix = ( matrix, calculator, operators ) =>
251 | matrix.map( calculator( operators ) )
252 |
253 | const result = calculateMatrix( matrix, calculate, operators )
254 | console.log(`result: ${result}`)
255 |
256 | /**
257 | result: 24,28,32,36,5,6,7,8,26,28,30,32,50,52,54,56
258 | */
259 |
260 | ```
261 |
262 | Com isso chegamos quase ao final do desafio, faltando apenas fazer o somatório para conferirmos se fizemos corretamente:
263 |
264 | ```
265 |
266 | Quando todos os calculos forem feitos, os novos valores do array devem ser somados juntamente com o [2, 4, 6, 8] ou seja:
267 |
268 | soma ([[2, 4, 6, 8], [24, 28, 32, 36], [5, 6, 7, 8], [26, 28, 30, 32], [50, 52, 54, 56]]) = 494
269 |
270 | O resultado final do cálculo é 494
271 |
272 | ```
273 |
274 | E claro que é extremamente facil de criarmos essa soluç˜ao, apenas aprecie:
275 |
276 |
277 | ```js
278 |
279 | const multiply = x => y => y * x
280 | const divide = x => y => y / x
281 | const minus = x => y => y - x
282 | const sum = x => y => y + x
283 | const concat = ( acc, cur ) => acc.concat( cur )
284 | const flatten = ( arr ) => arr.reduce( concat, [] )
285 |
286 | const operators = [
287 | multiply,
288 | divide,
289 | minus,
290 | sum
291 | ]
292 |
293 | const matrixBase = [
294 | [ 2, 4, 6, 8 ],
295 | [12, 14, 16, 18],
296 | [20, 24, 28, 32],
297 | [32, 34, 36, 38],
298 | [42, 44, 46, 48]
299 | ]
300 |
301 | const [ operatorsValues, ...matrix] = matrixBase
302 |
303 | const makeOperation = ( operators, operatorsValues, op ) => ( num ) =>
304 | operators[op]( operatorsValues[op] )(num)
305 |
306 | const calculate = ( operators ) => ( list, op ) =>
307 | list.map( makeOperation( operators, operatorsValues, op ) )
308 |
309 | const calculateMatrix = ( matrix, calculator, operators ) =>
310 | matrix.map( calculator( operators ) )
311 |
312 | const result = flatten(calculateMatrix( matrix, calculate, operators ))
313 | .concat( operatorsValues )
314 | .reduce( ( a, b ) => a + b, 0 )
315 |
316 | console.log(`result: ${result}`)
317 | // result: 494
318 |
319 |
320 | ```
321 |
322 | Ou até assim, fica ao seu gosto:
323 |
324 |
325 | ```js
326 |
327 | const operators = [
328 | x => y => y * x,
329 | x => y => y / x,
330 | x => y => y - x,
331 | x => y => y + x
332 | ]
333 |
334 | const matrixBase = [
335 | [ 2, 4, 6, 8 ],
336 | [12, 14, 16, 18],
337 | [20, 24, 28, 32],
338 | [32, 34, 36, 38],
339 | [42, 44, 46, 48]
340 | ]
341 |
342 | const [ operatorsValues, ...matrix] = matrixBase
343 |
344 | const concat = ( acc, cur ) => acc.concat( cur )
345 | const flatten = ( arr ) => arr.reduce( concat, [] )
346 |
347 | const makeOperation = ( operators, operatorsValues, op ) => ( num ) =>
348 | operators[op]( operatorsValues[op] )(num)
349 |
350 | const calculate = ( operators ) => ( list, op ) =>
351 | list.map( makeOperation( operators, operatorsValues, op ) )
352 |
353 | const calculateMatrix = ( matrix, calculator, operators ) =>
354 | matrix.map( calculator( operators ) )
355 |
356 | const sumAll = ( out, matrix ) =>
357 | matrix.concat( out )
358 | .reduce( ( a, b ) => a + b, 0 )
359 |
360 | const result = sumAll( operatorsValues,
361 | flatten( calculateMatrix( matrix, calculate, operators ) ) )
362 |
363 |
364 | console.log(`result: ${result}`)
365 | // result: 494
366 |
367 | ```
368 |
369 | ## Testando
370 |
371 | Vamos criar um teste simples para nos ajudar a validar nosso código:
372 |
373 | ```js
374 |
375 | const assert = require( 'assert' )
376 |
377 | const operators = [
378 | x => y => y * x,
379 | x => y => y / x,
380 | x => y => y - x,
381 | x => y => y + x
382 | ]
383 |
384 |
385 | const matrixBase = [
386 | [ 2, 4, 6, 8 ],
387 | [12, 14, 16, 18],
388 | [20, 24, 28, 32],
389 | [32, 34, 36, 38],
390 | [42, 44, 46, 48]
391 | ]
392 |
393 | const sumAll = require('./operators')
394 |
395 | const specSumAll = {
396 | _title: `Test sum all the values transformed`,
397 | _fn: sumAll,
398 | _in: matrixBase,
399 | _out: 494,
400 | calculated: sumAll( matrixBase, operators )
401 | }
402 |
403 | const testSpec = ( spec ) => {
404 | assert.deepEqual( spec._out, spec.calculated )
405 | }
406 |
407 | const specs = [
408 | specSumAll
409 | ]
410 |
411 | const runTest = ( test ) => {
412 | if ( testSpec( test ) === undefined ){
413 | console.log(`\n\t ${test._title} - passou!`)
414 | console.log(`\n\t\t Esperado: ${test._out}`)
415 | console.log(`\t\t Resultado: ${test.calculated}`)
416 | }
417 | }
418 |
419 |
420 | // Run this shit
421 |
422 | specs.map( runTest )
423 |
424 |
425 | ```
426 |
427 |
428 |
429 | > Percebeu que precisamos importar a funçao `sumAll`?
430 |
431 |
432 |
433 | Se temos a seguinte chamada `sumAll( matrixBase, operators )`, logo sabemos quais valores precisamos injetar nesse módulo e para isso **precisamos antes modulariza-lo!**
434 |
435 |
436 | ## Modularizando
437 |
438 | Nesse momento iremos entender o porquê criamos tantas funções puras e atômicas, primeiro passo é colocarmos nosso código como um módulo usando, ainda, o bom e velho `module.exports`.
439 |
440 | Vamos pensar que os únicos valores que precisamos passar é o *array* inteiro e quais operações queremos executar, logo podemos fazer assim:
441 |
442 | ```js
443 |
444 | module.exports = ( matrixBase, operators ) => { }
445 |
446 | ```
447 |
448 | Com isso precisamos criar a lógica mínima dentro do `module.exports`:
449 |
450 |
451 | ```js
452 |
453 | module.exports = ( matrixBase, operators ) => {
454 |
455 | const [ operatorsValues, ...matrix] = matrixBase
456 |
457 | return sumAll //...
458 | }
459 |
460 | ```
461 |
462 | Sabendo disso iremos deixar nosso `module.exports` assim:
463 |
464 |
465 | ```js
466 |
467 | module.exports = ( matrixBase, operators ) => {
468 |
469 | const [ operatorsValues, ...matrix ] = matrixBase
470 |
471 | return sumAll( operatorsValues,
472 | flatten( calculateMatrix( matrix,
473 | calculate,
474 | operators,
475 | operatorsValues
476 | )
477 | )
478 | )
479 | }
480 |
481 | ```
482 |
483 | Sim fiz pequenas mudanças para que tudo acontecesse perfeitamente.
484 |
485 |
486 | Finalizando nosso módulo, por hora, dessa forma:
487 |
488 |
489 |
490 | ```js
491 |
492 | const concat = ( acc, cur ) => acc.concat( cur )
493 | const flatten = ( arr ) => arr.reduce( concat, [] )
494 |
495 | const makeOperation = ( operators, operatorsValues, op ) => ( num ) =>
496 | operators[op]( operatorsValues[op] )(num)
497 |
498 | const calculate = ( operators, operatorsValues ) => ( list, op ) =>
499 | list.map( makeOperation( operators, operatorsValues, op ) )
500 |
501 | const calculateMatrix = ( matrix, calculator, operators, operatorsValues ) =>
502 | matrix.map( calculator( operators, operatorsValues ) )
503 |
504 | const sumAll = ( out, matrix ) =>
505 | matrix.concat( out )
506 | .reduce( ( a, b ) => a + b, 0 )
507 |
508 | module.exports = ( matrixBase, operators ) => {
509 |
510 | const [ operatorsValues, ...matrix ] = matrixBase
511 |
512 | return sumAll( operatorsValues,
513 | flatten( calculateMatrix( matrix,
514 | calculate,
515 | operators,
516 | operatorsValues
517 | )
518 | )
519 | )
520 | }
521 |
522 |
523 | ```
524 |
525 |
--------------------------------------------------------------------------------
/operators/suissa/index.functional.js:
--------------------------------------------------------------------------------
1 | const operators = [
2 | x => y => y * x,
3 | x => y => y / x,
4 | x => y => y - x,
5 | x => y => y + x
6 | ]
7 |
8 | const matrixBase = [
9 | [ 2, 4, 6, 8 ],
10 | [12, 14, 16, 18],
11 | [20, 24, 28, 32],
12 | [32, 34, 36, 38],
13 | [42, 44, 46, 48]
14 | ]
15 |
16 |
17 | const concat = ( acc, cur ) => acc.concat( cur )
18 | const flatten = ( arr ) => arr.reduce( concat, [] )
19 |
20 | const makeOperation = ( operators, operatorsValues, op ) => ( num ) =>
21 | operators[op]( operatorsValues[op] )(num)
22 |
23 | const calculate = ( operators ) => ( list, op ) =>
24 | list.map( makeOperation( operators, operatorsValues, op ) )
25 |
26 | const calculateMatrix = ( matrix, calculator, operators ) =>
27 | matrix.map( calculator( operators ) )
28 |
29 | const sumAll = ( out, matrix ) =>
30 | matrix.concat( out )
31 | .reduce( ( a, b ) => a + b, 0 )
32 |
33 | const [ operatorsValues, ...matrix] = matrixBase
34 |
35 | const result = sumAll( operatorsValues,
36 | flatten( calculateMatrix( matrix, calculate, operators ) ) )
37 |
38 |
39 | console.log(`result: ${result}`)
40 | // result: 494
41 |
42 |
43 |
--------------------------------------------------------------------------------
/operators/suissa/index.js:
--------------------------------------------------------------------------------
1 | const multiply = x => y => y * x
2 | const divide = x => y => y / x
3 | const minus = x => y => y - x
4 | const sum = x => y => y + x
5 |
6 | // ops === operators
7 | const ops = {
8 | multiply,
9 | divide,
10 | minus,
11 | sum
12 | }
13 |
14 | const opsFunctions = {
15 | multiply: 0,
16 | divide: 1,
17 | minus: 2,
18 | sum: 3
19 | }
20 |
21 | const matrixBase = [
22 | [ 2, 4, 6, 8 ],
23 | [12, 14, 16, 18],
24 | [20, 24, 28, 32],
25 | [32, 34, 36, 38],
26 | [42, 44, 46, 48]
27 | ]
28 |
29 | const [ opsValues, ...matrix] = matrixBase
30 |
31 | const multiplyByN = ops.multiply( opsValues[ opsFunctions.multiply ] )
32 | const resultMultiplyByN = matrix[ opsFunctions.multiply ].map( multiplyByN )
33 | console.log(`resultMultiplyByN: ${resultMultiplyByN}`)
34 |
35 | const divideByN = ops.divide( opsValues[ opsFunctions.divide ] )
36 | const resultDivideByN = matrix[ opsFunctions.divide ].map( divideByN )
37 | console.log(`resultDivideByN: ${resultDivideByN}`)
38 |
39 | const minusByN = ops.minus( opsValues[ opsFunctions.minus ] )
40 | const resultMinusByN = matrix[ opsFunctions.minus ].map( minusByN )
41 | console.log(`resultMinusByN: ${resultMinusByN}`)
42 |
43 |
44 | const sumByN = ops.sum( opsValues[ opsFunctions.sum ] )
45 | const resultSumByN = matrix[ opsFunctions.sum ].map( sumByN )
46 | console.log(`resultSumByN: ${resultSumByN}`)
47 |
48 |
49 | /**
50 | resultMultiplyByN: 24,28,32,36
51 | resultDivideByN: 5,6,7,8
52 | resultMinusByN: 26,28,30,32
53 | resultSumByN: 50,52,54,56
54 | */
--------------------------------------------------------------------------------
/operators/suissa/operators.js:
--------------------------------------------------------------------------------
1 | const concat = ( acc, cur ) => acc.concat( cur )
2 | const flatten = ( arr ) => arr.reduce( concat, [] )
3 |
4 | const makeOperation = ( operators, operatorsValues, op ) => ( num ) =>
5 | operators[op]( operatorsValues[op] )(num)
6 |
7 | const calculate = ( operators, operatorsValues ) => ( list, op ) =>
8 | list.map( makeOperation( operators, operatorsValues, op ) )
9 |
10 | const calculateMatrix = ( matrix, calculator, operators, operatorsValues ) =>
11 | matrix.map( calculator( operators, operatorsValues ) )
12 |
13 | const sumAll = ( out, matrix ) =>
14 | matrix.concat( out )
15 | .reduce( ( a, b ) => a + b, 0 )
16 |
17 | module.exports = ( matrixBase, operators ) => {
18 |
19 | const [ operatorsValues, ...matrix] = matrixBase
20 |
21 | return sumAll( operatorsValues,
22 | flatten( calculateMatrix( matrix,
23 | calculate,
24 | operators,
25 | operatorsValues
26 | )
27 | )
28 | )
29 | }
30 |
31 |
--------------------------------------------------------------------------------
/operators/suissa/operators.spec.js:
--------------------------------------------------------------------------------
1 | const assert = require( 'assert' )
2 |
3 | const operators = [
4 | x => y => y * x,
5 | x => y => y / x,
6 | x => y => y - x,
7 | x => y => y + x
8 | ]
9 |
10 |
11 | const matrixBase = [
12 | [ 2, 4, 6, 8 ],
13 | [12, 14, 16, 18],
14 | [20, 24, 28, 32],
15 | [32, 34, 36, 38],
16 | [42, 44, 46, 48]
17 | ]
18 |
19 | const sumAll = require('./operators')
20 |
21 | const specSumAll = {
22 | _title: `Test sum all the values transformed`,
23 | _fn: sumAll,
24 | _in: matrixBase,
25 | _out: 494,
26 | calculated: sumAll( matrixBase, operators )
27 | }
28 |
29 | // console.log(`\n\t sumAll: ${sumAll}!`)
30 | // console.log(`\n\t specSumAll.calculated: ${specSumAll.calculated}!`)
31 |
32 | // const specMultiply = {
33 | // _title: `Test multiply a list by 2`,
34 | // _fn: operators[0],
35 | // _in: 2,
36 | // _list: [12, 14, 16, 18],
37 | // _out: [24, 28, 32, 36],
38 | // calculated: []
39 |
40 | // }
41 |
42 |
43 | // const runOperation = ( spec ) =>
44 | // spec._list.map( spec._fn( spec._in ) )
45 |
46 | // specMultiply.calculated = runOperation( specMultiply )
47 |
48 |
49 |
50 | const testSpec = ( spec ) => {
51 | assert.deepEqual( spec._out, spec.calculated )
52 | }
53 |
54 | const specs = [
55 | // specMultiply,
56 | specSumAll
57 | ]
58 |
59 | const runTest = ( test ) => {
60 | if ( testSpec( test ) === undefined ){
61 | console.log(`\n\t ${test._title} - passou!`)
62 | console.log(`\n\t\t Esperado: ${test._out}`)
63 | console.log(`\t\t Resultado: ${test.calculated}`)
64 | }
65 | }
66 |
67 | // Run this shit
68 |
69 | specs.map( runTest )
70 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "webschool-js-challenges",
3 | "version": "1.0.0",
4 | "description": "> Repositório para centralizar os desafios de JS dos grupos de [Node.js](https://t.me/NodejsBR), [JavaScript](https://t.me/javascriptbrasil) e [JS4Girls](https://t.me/joinchat/AAAAAAv6M1fbEYWkmYFbSg)",
5 | "main": "index.js",
6 | "scripts": {
7 | "test": "echo \"Error: no test specified\" && exit 1"
8 | },
9 | "repository": {
10 | "type": "git",
11 | "url": "git+https://github.com/Webschool-io/js-desafios.git"
12 | },
13 | "author": "Suissa",
14 | "license": "WTFPL",
15 | "bugs": {
16 | "url": "https://github.com/Webschool-io/js-desafios/issues"
17 | },
18 | "homepage": "https://github.com/Webschool-io/js-desafios#readme",
19 | "dependencies": {
20 | "chai": "^3.5.0"
21 | }
22 | }
23 |
--------------------------------------------------------------------------------
/peculiaridades_matematicas/desafio.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Webschool-io/js-desafios/1f85d026b294cbad34016f6770c1221818e3163b/peculiaridades_matematicas/desafio.jpg
--------------------------------------------------------------------------------
/peculiaridades_matematicas/index.js:
--------------------------------------------------------------------------------
1 | const expect = require('chai').expect
2 |
3 | const getSquare = ( num ) => num * num
4 | const transformInString = ( something ) => something.toString()
5 | const getHalf = ( something ) => Math.floor( something.length / 2 )
6 |
7 | const resolvePeculiarity = ( num ) => {
8 | const str = transformInString( getSquare( num ) )
9 | const half = getHalf( str )
10 | return parseInt( str.slice(0, half) ) + parseInt( str.slice(half) )
11 | }
12 |
13 | const resolveChallenge = resolvePeculiarity
14 |
15 | describe('Teste se consegue transformar 99 virar 100 usando somente o número 9', () => {
16 |
17 | it('Se 9 ^ 2 = 81 entao 8 + 1 deve ser 9', () => {
18 | const num = 9
19 | const result = resolveChallenge( num )
20 | expect( result ).to.equal( num )
21 | })
22 |
23 | it('Se 45 ^ 2 = 2025 entao 20 + 25 deve ser 45', () => {
24 | const num = 45
25 | const result = resolveChallenge( num )
26 | expect( result ).to.equal( num )
27 | })
28 |
29 | it('Se 55 ^ 2 = 3025 entao 30 + 25 deve ser 55', () => {
30 | const num = 55
31 | const result = resolveChallenge( num )
32 | expect( result ).to.equal( num )
33 | })
34 |
35 |
36 | it('Se 99 ^ 2 = 9801 entao 98 + 01 deve ser 99', () => {
37 | const num = 99
38 | const result = resolveChallenge( num )
39 | expect( result ).to.equal( num )
40 | })
41 |
42 | it('Se 297 ^ 2 = 88209 entao 88 + 209 deve ser 297', () => {
43 | const num = 297
44 | const result = resolveChallenge( num )
45 | expect( result ).to.equal( num )
46 | })
47 |
48 | it('Se 703 ^ 2 = 88209 entao 494 + 209 deve ser 703', () => {
49 | const num = 703
50 | const result = resolveChallenge( num )
51 | expect( result ).to.equal( num )
52 | })
53 |
54 | it('Se 999 ^ 2 = 998001 entao 998 + 001 deve ser 999', () => {
55 | const num = 999
56 | const result = resolveChallenge( num )
57 | expect( result ).to.equal( num )
58 | })
59 |
60 | })
--------------------------------------------------------------------------------
/peculiaridades_matematicas/readme.md:
--------------------------------------------------------------------------------
1 | # Desafio - Peculiaridades Matematicas
2 |
3 | 
4 |
5 | Percebemos pela imagem que:
6 |
7 | ```
8 |
9 | X ^ 2 = Y
10 |
11 | // quebre o Y na metade e some esses valores, exemplo:
12 |
13 | 9 ^ 2 = 81
14 | 8 + 1 = 9
15 |
16 | 45 ^ 2 = 2025
17 | 20 + 25 = 45
18 |
19 | ...
20 |
21 | ```
--------------------------------------------------------------------------------
/show-me-evens-odds/readme.md:
--------------------------------------------------------------------------------
1 | # Show Me the Evens - Show me the Odds
2 |
3 | Diana is learning to count and she just learned the difference between odds and even numbers.
4 | She wants to have some fun, so she picks a random number.
5 | If that number is even, she decides to count all the even numbers up to it starting from 0 up to (but not including) the input.
6 | If not, she decides to count all the odd numbers up to that number starting from 1 (but not including) the input.
7 |
--------------------------------------------------------------------------------
/show-me-evens-odds/suissa/index.js:
--------------------------------------------------------------------------------
1 | const props = {
2 | even: (num) => !(num % 2),
3 | odd: (num) => (num % 2)
4 | }
5 |
6 | const rangeGenerator = ( range ) =>
7 | [].concat( ...Array( range ).keys() )
8 |
9 | const filterByType = ( props, type ) => ( key ) => props[type](key)
10 |
11 | const result = (range, type) =>
12 | rangeGenerator( range ).filter( filterByType( props, type ) )
13 |
14 | console.log( `\n even:`, result(20, 'even' ) )
15 | console.log( `\n odd:`, result(20, 'odd') )
--------------------------------------------------------------------------------