Kumite (ko͞omiˌtā) is the practice of taking techniques learned from Kata and applying them through the act of freestyle sparring.
You can create a new kumite by providing some initial code and optionally some test cases. From there other warriors can spar with you, by enhancing, refactoring and translating your code. There is no limit to how many warriors you can spar with.
A great use for kumite is to begin an idea for a kata as one. You can collaborate with other code warriors until you have it right, then you can convert it to a kata.
Com destructuring conseguimos ser precisos quanto aos valores que queremos acessar e com spread acumulamos o que sobrou. Usando esses dois recursos em conjunto conseguimos o efeito contrário, remover o desnecessário e guardar o restante.
Exercício:
- Converta rem para arrow function
- Use destructuring e spread operator para remover keywords do objeto principal
- Retorne o novo objeto e armazene na variável obj2
const main = () => {
let obj = {
title: 'UOL - O melhor conteúdo',
url: 'https://www.uol',
keywords: ['Notícias', 'Entretenimento']
};
// converta para ES6
function rem(obj) {
delete obj.keywords;
return obj;
}
var obj2 = rem(obj);
return obj.hasOwnProperty('keywords') && !obj2.hasOwnProperty('keywords');
};describe("Solution", function(){
it("should test for something", function(){
Test.assertEquals(main(), true, "Victory");
});
});Não há limite para a quantidade de parâmetros que você pode enviar para uma função JS. A assinatura é um meio mais fácil de acessar alguns desses parâmetros. Em alguns casos pode ser muito útil definir assumir um valor padrão quando o parâmetro é opcional. Uma forma de verificar se o parâmetro foi ou não definido é validar com undefined. Só que com ES6 existe uma forma mais simples e elegante de tornar parâmetros opcionais.
Exercício:
Reescreva o código em ES6.
// reescreva em ES6
function main(a, b, c) {
if (typeof b == 'undefined')
b = 2;
if (typeof c == 'undefined')
c = 3
return a * b * c;
}describe("Solution", function(){
it("validating", function(){
Test.assertEquals(main(1), 6, "b e c opcionais");
Test.assertEquals(main(2, 3), 18, "c opcional");
Test.assertEquals(main(2, 2, 2), 8, "todos parâmetros");
});
});Além de trazer novidades na escrita da linguagem, ES6 também trouxe novas classes.
Exercício:
Remover os itens duplicados do array sem percorrer o array
const main = () => {
let links = [
'https://www.uol',
'https://www.bol.com.br',
'https://www.uol',
'https://noticias.uol.com.br',
'https://www.bol.com.br',
];
// converter para ES6
var uniqueLinks = links.reduce(function (carry, item) {
if (carry.indexOf(item) === -1) {
carry.push(item);
}
return carry;
}, []);
return uniqueLinks.length;
};Async / await vieram para facilitar a execução de código assíncrono, muitas vezes encapsulado em Promises e dar maior controle sobre o fluxo de execução, dando a possibilidade de transformar trechos assíncronos em síncronos evitando callbacks excessivos (callback from hell).
Exercício:
Converta a execução da Promise para async/await.
function monteCarlo() {
return new Promise(function (resolve, reject) {
resolve([{
titulo: 'UOL - O Melhor conteúdo'
}]);
});
}
async function main() {
// converter para ES6
monteCarlo().then(function(response) {
console.log(response)
});
return true;
}describe("Solution", function(){
it("should test for something", async function(){
Test.assertEquals(await main(), true, "This is just an example of how you can write your own TDD tests");
});
});"Você precisa disso para agora?"
Ou então apenas repasse.
Generator é uma instrução que fica na espera, somente é executada quando necessário.
Exercício:
Percorrer o generator na função main e para cada item imprimir no console seu valor.
function* lazyRange(start, stop) {
while (start <= stop) {
console.log(`Interando ${start}`);
yield start;
++start;
}
}
function createRange() {
console.log("Criando um range");
return lazyRange(1, 10);
}
function getData() {
let theRange = createRange();
console.log("Repassando o range");
return {theRange};
}
function main() {
let resp = getData();
// percorra o generator executando o trecho comentado abaixo
// console.log(`Valor ${item}`);
return 1;
}describe("Solution", function(){
it("should test for something", function(){
Test.assertEquals(main(), 1, "This is just an example of how you can write your own TDD tests");
});
});LazyRange cria um range de um número até outro com generators. O benefício do generator é que o range só será criado quando necessário.
E se pudermos alinhar generators de forma que várias instruções sejam executadas porém somente quando necessário, evitando percorrer o mesmo array diversas vezes?
Estamos falando de pura performance.
Exercício:
Implementar a função plusOne que some 1 em cada item de doubleRangeValue e retorne os valores sob demanda (generator).
function* lazyRange(start, stop) {
while (start <= stop) {
console.log(`Interando ${start}`);
yield start;
++start;
}
}
function* doubleRangeValue(...args) {
for (let value of lazyRange(...args)) {
value *= 2;
console.log(`Dobro ${value}`);
yield value;
}
}
function* plusOne() {
// implemente
}
async function main() {
let resp = [...plusOne(1, 5)];
return resp.join(',');
}describe("Solution", function(){
it("should test for something", async function(){
Test.assertEquals(await main(), "3,5,7,9,11", "Victory");
});
});Quando usar for, forEach, map ou reduce?
Todos percorrem uma lista. Então se o problema exige percorrer uma lista qualquer um deles resolvem.
Mas cada um foi projetado para resolver um tipo de problema e quando aplicado tende a deixar o código mais legível e com menos linhas.
Exercício:
Resposta cada função com "for", "forEach", "map" ou "reduce" no return.
function a() {
"Atualizar o array com o dobro de seus valores"
let a = [1, 2, 3, 4];
a.forEach((item, index) => {
a[index] = item * 2;
});
// responda: for, forEach, map ou reduce
return '';
}
function b() {
"Em uma nova variável atribuir a soma dos valores do array"
let a = [4, 10, 23, 99];
let r = 0;
a.map(item => {
r += item;
});
// responda: for, forEach, map ou reduce
return '';
}
function c() {
"Em um novo array o quadrado dos itens de A"
let a = [4, 8, 16];
let r = a.map(item => Math.pow(item, 2));
// responda: for, forEach, map ou reduce
return '';
}
function d() {
"Encontrar no array um item que seja maior ou igual a 2"
let a = [1, 2, 3, 4];
let resp = null;
a.forEach((item, index) => {
if (item >= 2) {
resp = item;
break;
}
});
// responda: for, forEach, map ou reduce
return '';
}
function e() {
"Um novo array com valores únicos de A"
let a = [1, 2, 2, 3, 4];
let b = [];
for (const item of a) {
if (!b.includes(item))
b.push(b);
}
// responda: for, forEach, map ou reduce
return '';
}
function f() {
"Novo array com itens de índice par"
let a = ['a', 'b', 'c', 'd'];
let b = [];
a.map((item, index) => {
if (index % 2 == 0) {
b.push(item);
}
});
// responda: for, forEach, map ou reduce
return '';
}
function g() {
"Executar chamadas http de forma assíncrona"
let a = ['/p=1', '/p=2', '/p=3'];
for (let path of a) {
let xhr = new function() {};
// ...
}
// responda: for, forEach, map ou reduce
return '';
}
function h() {
"Novo array com apenas titulo e descrição de uma resposta no Monte Carlo"
let results = [{titulo: '..', descricao: '', tags: [], photo: '...'}];
let resp = results.map(({titulo, descricao}) => ({titulo, descricao}));
// responda: for, forEach, map ou reduce
return '';
}
function i() {
"Descompactar a matriz em uma lista"
let a = [[1, 2], [4, 5], [4, 5]];
let resp = a.reduce((carry, row) => ([...carry, ...row]), []);
// responda: for, forEach, map ou reduce
return '';
}
function j() {
"Multiplicar matrizes"
let a = [1, 2, 3];
let b = [4, 5, 6];
let resp = a.reduce((carry, v, i) => carry + v * b[i], 0);
// responda: for, forEach, map ou reduce
return '';
}
function k() {
"Transformar as letras em maiúsculas"
let a = ['Fred', 'John', 'Paul'];
for (const [index, value] of a.entries()) {
a[index] = value.toUpperCase();
}
// responda: for, forEach, map ou reduce
return '';
}
function l() {
"Exibir no console as chaves e os valores"
let config = {portal: 'UOL', channel: 'Notícias', slug: 'uol'};
for (const prop in config) {
console.log(prop, config[prop]);
}
// responda: for, forEach, map ou reduce
return '';
}
function m() {
"Exibir no console os itens do array"
let tags = ['São Paulo', 'Sudeste', 'Brasil'];
for (const k in tags) {
console.log(tags[k]);
}
// responda: for, forEach, map ou reduce
return '';
}/*
*/
describe("Solution", function(){
it("should test for something", function(){
Test.assertEquals(a(), "forEach", "Um novo array com a mesma quantidade de itens, mas com valor modificados: map");
Test.assertEquals(b(), "reduce", "Reduzir o array a um número cuja representa a soma de todos os itens: reduce");
Test.assertEquals(c(), "map", "Mesma quantidade de itens, valores modificados: map");
Test.assertEquals(d(), "forEach", "Altera o array principal e ainda mais dados sem referência: forEach");
Test.assertEquals(e(), "reduce", "O array é reduzido, removendo duplicados: reduce");
Test.assertEquals(f(), "reduce", "forEach seria a melhor escolha se reduce não tivesse o índice do item: reduce");
Test.assertEquals(g(), "for", "Percorrer os itens do array executando alguma operação: for. Caso tivesse que garantir a ordem das chamadas http seria necessário outra solução.");
Test.assertEquals(h(), "map", "Um novo array com a mesma quantidade de itens, mas com alguns valores modificados: map");
Test.assertEquals(i(), "reduce", "Um novo array modificado: reduce");
Test.assertEquals(j(), "reduce", "Somatória de um cálculo envolvendo matrizes: reduce");
Test.assertEquals(k(), "forEach", "Naturalmente forEach traz o índice do array: forEach");
Test.assertEquals(l(), "for", "For in acessa as chaves do objeto");
Test.assertEquals(m(), "for", "For com resalva de ser for-of");
});
});Antes do ES6 não havia classes no Javascript. Combinando new e function conseguíamos algo parecido, criando um escopo para this. E com protótipo simular uma herança. Velhos tempos! (Que fique no passado).
Exercício:
Reescreva o código usando class.
function Component(dom) {
this.dom = dom;
this.onCreate = function() {
return this.dom;
}
}describe("Solution", function(){
it("Testando a classe", function(){
Test.assertEquals((new Component(1)).onCreate(), 1, "Victory");
});
});Given a matrix return the row that is of different length than other rows, it can be greater or lesser than the other rows. The rows can contain anything (numbers, characters, strings,floats,etc). The matrix will always have more than 2 rows and only one row will be estranged from the others.
Some examples:
estranged_row([[1,2,3,4],
[5,6,7,8],
[9,10,11]])
will return a value of 2(the last row)
estranged_row([[9,2],
[24],
['a',8]])
will return a value of 1 (the middle row)
estranged_row([[9,'a',0.1,'alpha'],
[22,'a',46,(82,24)],
[9,3,22,11],
[(1,8),22,35,72],
[18,22,['fox','rabbit','clover']]])
will return a value of 4 (the last row)
from collections import Counter
def estranged_row(m:list) -> int:
estr= Counter([len(a) for a in m]).most_common(1)[0][0]
for index,items in enumerate(m):
if len(items) != estr:
return indexTest.describe("Basic tests")
test.assert_equals(estranged_row([[1,2,3,4],[5,6,7,8],[9,10,11]]),2)
test.assert_equals(estranged_row([[1,2,3,3,4],[2,3,4],[2,8,9]]),0)
Test.describe("Testing different data types")
test.assert_equals(estranged_row([[9,2],[24],['a',8]]),1)
test.assert_equals(estranged_row([[9,'a',0.1,'alpha'],
[22,'a',46,(82,24)],
[9,3,22,11],
[(1,8),22,35,72],
[18,22,['fox','rabbit','clover']]]),4)Com ES6 a criação de métodos ficou mais simples, não precisa mais da keyword "function".
Além disso podemos definir o nome das propriedades de forma dinâmica na definição do objeto.
Exercício:
- Reescreva o código usando ES6
- Simplifique a definição do método myFunc
- Declare a propriedade de nome dinâmico no objeto na definição principal.
// reescreva usando ES6
var prop = 'myProp';
var obj = {
myFunc: function() {
return this[prop];
}
};
obj[prop] = 123;describe("Solution", function(){
it("Conectando ao Universo", function(){
Test.assertEquals(obj.myFunc(), 123, "Victory");
});
});