Skip to content

Commit da6ae08

Browse files
StPfeffertrekhleb
StPfeffer
and
trekhleb
authoredOct 10, 2022
Brazilian Portuguese translation and typos fixes (trekhleb#943)
* Update README.pt-BR.md * TRIE README.pt-BR typo * TREE README.pt-BR typo * Stack README.pt-BR typo * Priority Queue README.pt-BR typo * hash-table README.pt-BR typo * doubly-linked-list README.pt-BR typo * disjoint-set README.pt-BR typo * bloom-filter README.pt-BR typo * merge-sort pt-BR translation * merge-sort README added pt-BR option * insertion sort pt-BR translation * insertion sort README added pt-br option * heap-sort pt-BR translation * heap-sort READMED added pt-BR option * bubble sort pt-BR typo * pt-BR translation for sorting algorithms Fixed typos and translated all the missing algorithms * Update README.pt-BR.md * linked list pt-BR translation * ml pt-BR translation * fix typo in README Co-authored-by: Oleksii Trekhleb <[email protected]>
1 parent 9ef6650 commit da6ae08

File tree

34 files changed

+567
-145
lines changed

34 files changed

+567
-145
lines changed
 

‎README.pt-BR.md

+112-105
Large diffs are not rendered by default.

‎src/algorithms/linked-list/reverse-traversal/README.md

+2-1
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,8 @@
11
# Reversed Linked List Traversal
22

33
_Read this in other languages:_
4-
[中文](README.zh-CN.md)
4+
[_中文_](README.zh-CN.md),
5+
[_Português_](README.pt-BR.md)
56

67
The task is to traverse the given linked list in reversed order.
78

‎src/algorithms/linked-list/reverse-traversal/README.pt-BR.md

+23
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
# Travessia de Lista Encadeada Reversa
2+
3+
_Leia isso em outros idiomas:_
4+
[_中文_](README.zh-CN.md),
5+
[_English_](README.md)
6+
7+
A tarefa é percorrer a lista encadeada fornecida em ordem inversa.
8+
9+
Por exemplo, para a seguinte lista vinculada:
10+
11+
![](https://upload.wikimedia.org/wikipedia/commons/6/6d/Singly-linked-list.svg)
12+
13+
A ordem de travessia deve ser:
14+
15+
```texto
16+
37 → 99 → 12
17+
```
18+
19+
A complexidade de tempo é `O(n)` porque visitamos cada nó apenas uma vez.
20+
21+
## Referência
22+
23+
- [Wikipedia](https://en.wikipedia.org/wiki/Linked_list)

‎src/algorithms/linked-list/traversal/README.md

+2-1
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,8 @@
22

33
_Read this in other languages:_
44
[_Русский_](README.ru-RU.md),
5-
[中文](README.zh-CN.md)
5+
[_中文_](README.zh-CN.md),
6+
[_Português_](README.pt-BR.md)
67

78
The task is to traverse the given linked list in straight order.
89

‎src/algorithms/linked-list/traversal/README.pt-BR.md

+24
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
# Travessia de Lista Encadeada
2+
3+
_Leia isso em outros idiomas:_
4+
[_Русский_](README.ru-RU.md),
5+
[_中文_](README.zh-CN.md),
6+
[_English_](README.md)
7+
8+
A tarefa é percorrer a lista encadeada fornecida em ordem direta.
9+
10+
Por exemplo, para a seguinte lista vinculada:
11+
12+
![Singly linked list](https://upload.wikimedia.org/wikipedia/commons/6/6d/Singly-linked-list.svg)
13+
14+
A ordem de travessia deve ser:
15+
16+
```texto
17+
12 → 99 → 37
18+
```
19+
20+
A complexidade de tempo é `O(n)` porque visitamos cada nó apenas uma vez.
21+
22+
## Referência
23+
24+
- [Wikipedia](https://en.wikipedia.org/wiki/Linked_list)

‎src/algorithms/ml/k-means/README.md

+3
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,8 @@
11
# k-Means Algorithm
22

3+
_Read this in other languages:_
4+
[_Português_](README.pt-BR.md)
5+
36
The **k-Means algorithm** is an unsupervised Machine Learning algorithm. It's a clustering algorithm, which groups the sample data on the basis of similarity between dimensions of vectors.
47

58
In k-Means classification, the output is a set of classes assigned to each vector. Each cluster location is continuously optimized in order to get the accurate locations of each cluster such that they represent each group clearly.

‎src/algorithms/ml/k-means/README.pt-BR.md

+35
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,35 @@
1+
# Algoritmo k-Means
2+
3+
_Leia isso em outros idiomas:_
4+
[_English_](README.md)
5+
6+
O **algoritmo k-Means** é um algoritmo de aprendizado de máquina não supervisionado. É um algoritmo de agrupamento, que agrupa os dados da amostra com base na semelhança entre as dimensões dos vetores.
7+
8+
Na classificação k-Means, a saída é um conjunto de classes atribuídas a cada vetor. Cada localização de cluster é continuamente otimizada para obter as localizações precisas de cada cluster de forma que representem cada grupo claramente.
9+
10+
A ideia é calcular a similaridade entre a localização do cluster e os vetores de dados e reatribuir os clusters com base nela. [Distância Euclidiana](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/euclidean-distance) é usado principalmente para esta tarefa.
11+
12+
![Distância Euclidiana entre dois pontos](https://upload.wikimedia.org/wikipedia/commons/5/55/Euclidean_distance_2d.svg)
13+
14+
_Fonte: [Wikipedia](https://en.wikipedia.org/wiki/Euclidean_distance)_
15+
16+
O algoritmo é o seguinte:
17+
18+
1. Verifique se há erros como dados inválidos/inconsistentes
19+
2. Inicialize os locais do cluster `k` com pontos `k` iniciais/aleatórios
20+
3. Calcule a distância de cada ponto de dados de cada cluster
21+
4. Atribua o rótulo do cluster de cada ponto de dados igual ao do cluster em sua distância mínima
22+
5. Calcule o centroide de cada cluster com base nos pontos de dados que ele contém
23+
6. Repita cada uma das etapas acima até que as localizações do centroide estejam variando
24+
25+
Aqui está uma visualização do agrupamento k-Means para melhor compreensão:
26+
27+
![KNN Visualization 1](https://upload.wikimedia.org/wikipedia/commons/e/ea/K-means_convergence.gif)
28+
29+
_Fonte: [Wikipedia](https://en.wikipedia.org/wiki/K-means_clustering)_
30+
31+
Os centroides estão se movendo continuamente para criar uma melhor distinção entre os diferentes conjuntos de pontos de dados. Como podemos ver, após algumas iterações, a diferença de centroides é bastante baixa entre as iterações. Por exemplo, entre as iterações `13` e `14` a diferença é bem pequena porque o otimizador está ajustando os casos limite.
32+
33+
## Referências
34+
35+
- [k-Means neighbors algorithm on Wikipedia](https://en.wikipedia.org/wiki/K-means_clustering)

‎src/algorithms/ml/knn/README.md

+3
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,8 @@
11
# k-Nearest Neighbors Algorithm
22

3+
_Read this in other languages:_
4+
[_Português_](README.pt-BR.md)
5+
36
The **k-nearest neighbors algorithm (k-NN)** is a supervised Machine Learning algorithm. It's a classification algorithm, determining the class of a sample vector using a sample data.
47

58
In k-NN classification, the output is a class membership. An object is classified by a plurality vote of its neighbors, with the object being assigned to the class most common among its `k` nearest neighbors (`k` is a positive integer, typically small). If `k = 1`, then the object is simply assigned to the class of that single nearest neighbor.

‎src/algorithms/ml/knn/README.pt-BR.md

+44
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,44 @@
1+
# Algoritmo de k-vizinhos mais próximos
2+
3+
_Leia isso em outros idiomas:_
4+
[_English_](README.md)
5+
6+
O **algoritmo de k-vizinhos mais próximos (k-NN)** é um algoritmo de aprendizado de máquina supervisionado. É um algoritmo de classificação, determinando a classe de um vetor de amostra usando dados de amostra.
7+
8+
Na classificação k-NN, a saída é uma associação de classe. Um objeto é classificado por uma pluralidade de votos de seus vizinhos, com o objeto sendo atribuído à classe mais comum entre seus `k` vizinhos mais próximos (`k` é um inteiro positivo, tipicamente pequeno). Se `k = 1`, então o objeto é simplesmente atribuído à classe daquele único vizinho mais próximo.
9+
10+
The idea is to calculate the similarity between two data points on the basis of a distance metric. [Distância Euclidiana](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/euclidean-distance) é usado principalmente para esta tarefa.
11+
12+
![Distância Euclidiana entre dois pontos](https://upload.wikimedia.org/wikipedia/commons/5/55/Euclidean_distance_2d.svg)
13+
14+
_Fonte: [Wikipedia](https://en.wikipedia.org/wiki/Euclidean_distance)_
15+
16+
O algoritmo é o seguinte:
17+
18+
1. Verifique se há erros como dados/rótulos inválidos.
19+
2. Calcule a distância euclidiana de todos os pontos de dados nos dados de treinamento com o ponto de classificação
20+
3. Classifique as distâncias dos pontos junto com suas classes em ordem crescente
21+
4. Pegue as classes iniciais `K` e encontre o modo para obter a classe mais semelhante
22+
5. Informe a classe mais semelhante
23+
24+
Aqui está uma visualização da classificação k-NN para melhor compreensão:
25+
26+
![KNN Visualization 1](https://upload.wikimedia.org/wikipedia/commons/e/e7/KnnClassification.svg)
27+
28+
_Fonte: [Wikipedia](https://en.wikipedia.org/wiki/K-nearest_neighbors_algorithm)_
29+
30+
A amostra de teste (ponto verde) deve ser classificada em quadrados azuis ou em triângulos vermelhos. Se `k = 3` (círculo de linha sólida) é atribuído aos triângulos vermelhos porque existem `2` triângulos e apenas `1` quadrado dentro do círculo interno. Se `k = 5` (círculo de linha tracejada) é atribuído aos quadrados azuis (`3` quadrados vs. `2` triângulos dentro do círculo externo).
31+
32+
Outro exemplo de classificação k-NN:
33+
34+
![KNN Visualization 2](https://media.geeksforgeeks.org/wp-content/uploads/graph2-2.png)
35+
36+
_Fonte: [GeeksForGeeks](https://media.geeksforgeeks.org/wp-content/uploads/graph2-2.png)_
37+
38+
Aqui, como podemos ver, a classificação dos pontos desconhecidos será julgada pela proximidade com outros pontos.
39+
40+
É importante notar que `K` é preferível ter valores ímpares para desempate. Normalmente `K` é tomado como `3` ou `5`.
41+
42+
## Referências
43+
44+
- [k-nearest neighbors algorithm on Wikipedia](https://en.wikipedia.org/wiki/K-nearest_neighbors_algorithm)

‎src/algorithms/sorting/bubble-sort/README.pt-BR.md

+7-4
Original file line numberDiff line numberDiff line change
@@ -1,16 +1,19 @@
11
# Bubble Sort
22

3+
_Leia isso em outros idiomas:_
4+
[_English_](README.md)
5+
36
O bubble sort, ou ordenação por flutuação (literalmente "por bolha"), é um algoritmo de ordenação dos mais simples. A ideia é percorrer o vetor diversas vezes, e a cada passagem fazer flutuar para o topo o maior elemento da sequência. Essa movimentação lembra a forma como as bolhas em um tanque de água procuram seu próprio nível, e disso vem o nome do algoritmo.
47

58
![Algorithm Visualization](https://upload.wikimedia.org/wikipedia/commons/c/c8/Bubble-sort-example-300px.gif)
69

7-
## Complexity
10+
## Complexidade
811

9-
| Name | Best | Average | Worst | Memory | Stable | Comments |
12+
| Nome | Melhor | Média | Pior | Memória | Estável | Comentários |
1013
| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
11-
| **Bubble sort** | n | n<sup>2</sup> | n<sup>2</sup> | 1 | Yes | |
14+
| **Bubble sort** | n | n<sup>2</sup> | n<sup>2</sup> | 1 | Sim | |
1215

13-
## References
16+
## Referências
1417

1518
- [Wikipedia](https://pt.wikipedia.org/wiki/Bubble_sort)
1619
- [YouTube](https://www.youtube.com/watch?v=6Gv8vg0kcHc&index=27&t=0s&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)

‎src/algorithms/sorting/counting-sort/README.md

+3
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,8 @@
11
# Counting Sort
22

3+
_Read this in other languages:_
4+
[_Português_](README.pt-BR.md)
5+
36
In computer science, **counting sort** is an algorithm for sorting
47
a collection of objects according to keys that are small integers;
58
that is, it is an integer sorting algorithm. It operates by

‎src/algorithms/sorting/counting-sort/README.pt-br.md

+70
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,70 @@
1+
# Counting Sort
2+
3+
_Leia isso em outros idiomas:_
4+
[_English_](README.md)
5+
6+
Em ciência da computação, **counting sort** é um algoritmo para ordenar
7+
uma coleção de objetos de acordo com chaves que são pequenos inteiros;
8+
ou seja, é um algoritmo de ordenação de inteiros. Ele opera por
9+
contando o número de objetos que têm cada valor de chave distinto,
10+
e usando aritmética nessas contagens para determinar as posições
11+
de cada valor de chave na sequência de saída. Seu tempo de execução é
12+
linear no número de itens e a diferença entre o
13+
valores de chave máximo e mínimo, portanto, é adequado apenas para
14+
uso em situações em que a variação de tonalidades não é significativamente
15+
maior que o número de itens. No entanto, muitas vezes é usado como
16+
sub-rotina em outro algoritmo de ordenação, radix sort, que pode
17+
lidar com chaves maiores de forma mais eficiente.
18+
19+
Como a classificação por contagem usa valores-chave como índices em um vetor,
20+
não é uma ordenação por comparação, e o limite inferior `Ω(n log n)` para
21+
a ordenação por comparação não se aplica a ele. A classificação por bucket pode ser usada
22+
para muitas das mesmas tarefas que a ordenação por contagem, com um tempo semelhante
23+
análise; no entanto, em comparação com a classificação por contagem, a classificação por bucket requer
24+
listas vinculadas, arrays dinâmicos ou uma grande quantidade de pré-alocados
25+
memória para armazenar os conjuntos de itens dentro de cada bucket, enquanto
26+
A classificação por contagem armazena um único número (a contagem de itens)
27+
por balde.
28+
29+
A classificação por contagem funciona melhor quando o intervalo de números para cada
30+
elemento do vetor é muito pequeno.
31+
32+
## Algoritmo
33+
34+
**Passo I**
35+
36+
Na primeira etapa, calculamos a contagem de todos os elementos do
37+
vetor de entrada 'A'. Em seguida, armazene o resultado no vetor de contagem `C`.
38+
A maneira como contamos é descrita abaixo.
39+
40+
![Counting Sort](https://3.bp.blogspot.com/-jJchly1BkTc/WLGqCFDdvCI/AAAAAAAAAHA/luljAlz2ptMndIZNH0KLTTuQMNsfzDeFQCLcB/s1600/CSortUpdatedStepI.gif)
41+
42+
**Passo II**
43+
44+
Na segunda etapa, calculamos quantos elementos existem na entrada
45+
do vetor `A` que são menores ou iguais para o índice fornecido.
46+
`Ci` = números de elementos menores ou iguais a `i` no vetor de entrada.
47+
48+
![Counting Sort](https://1.bp.blogspot.com/-1vFu-VIRa9Y/WLHGuZkdF3I/AAAAAAAAAHs/8jKu2dbQee4ap9xlVcNsILrclqw0UxAVACLcB/s1600/Step-II.png)
49+
50+
**Passo III**
51+
52+
Nesta etapa, colocamos o elemento `A` do vetor de entrada em classificado
53+
posição usando a ajuda do vetor de contagem construída `C`, ou seja, o que
54+
construímos no passo dois. Usamos o vetor de resultados `B` para armazenar
55+
os elementos ordenados. Aqui nós lidamos com o índice de `B` começando de
56+
zero.
57+
58+
![Counting Sort](https://1.bp.blogspot.com/-xPqylngqASY/WLGq3p9n9vI/AAAAAAAAAHM/JHdtXAkJY8wYzDMBXxqarjmhpPhM0u8MACLcB/s1600/ResultArrayCS.gif)
59+
60+
## Complexidade
61+
62+
| Nome | Melhor | Média | Pior | Memória | Estável | Comentários |
63+
| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
64+
| **Counting sort** | n + r | n + r | n + r | n + r | Sim | r - Maior número no vetor |
65+
66+
## Referências
67+
68+
- [Wikipedia](https://en.wikipedia.org/wiki/Counting_sort)
69+
- [YouTube](https://www.youtube.com/watch?v=OKd534EWcdk&index=61&t=0s&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
70+
- [EfficientAlgorithms](https://efficientalgorithms.blogspot.com/2016/09/lenear-sorting-counting-sort.html)

‎src/algorithms/sorting/heap-sort/README.md

+3
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,8 @@
11
# Heap Sort
22

3+
_Read this in other languages:_
4+
[_Português_](README.pt-BR.md)
5+
36
Heapsort is a comparison-based sorting algorithm.
47
Heapsort can be thought of as an improved selection
58
sort: like that algorithm, it divides its input into

‎src/algorithms/sorting/heap-sort/README.pt-BR.md

+20
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
# Heap Sort
2+
3+
_Leia isso em outros idiomas:_
4+
[_English_](README.md)
5+
6+
Heapsort é um algoritmo de ordenação baseado em comparação. O Heapsort pode ser pensado como uma seleção aprimorada sort: como esse algoritmo, ele divide sua entrada em uma região classificada e uma região não classificada, e iterativamente encolhe a região não classificada extraindo o maior elemento e movendo-o para a região classificada. A melhoria consiste no uso de uma estrutura de dados heap em vez de uma busca em tempo linear para encontrar o máximo.
7+
8+
![Visualização do Algoritmo](https://upload.wikimedia.org/wikipedia/commons/1/1b/Sorting_heapsort_anim.gif)
9+
10+
![Visualização do Algoritmo](https://upload.wikimedia.org/wikipedia/commons/4/4d/Heapsort-example.gif)
11+
12+
## Complexidade
13+
14+
| Nome | Melhor | Média | Pior | Memória | Estável | Comentários |
15+
| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
16+
| **Heap sort** | n&nbsp;log(n) | n&nbsp;log(n) | n&nbsp;log(n) | 1 | Não | |
17+
18+
## Referências
19+
20+
[Wikipedia](https://en.wikipedia.org/wiki/Heapsort)

‎src/algorithms/sorting/insertion-sort/README.md

+3
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,8 @@
11
# Insertion Sort
22

3+
_Read this in other languages:_
4+
[_Português_](README.pt-BR.md)
5+
36
Insertion sort is a simple sorting algorithm that builds
47
the final sorted array (or list) one item at a time.
58
It is much less efficient on large lists than more

‎src/algorithms/sorting/insertion-sort/README.pt-BR.md

+22
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
# Insertion Sort
2+
3+
_Leia isso em outros idiomas:_
4+
[_English_](README.md)
5+
6+
A ordenação por inserção é um algoritmo de ordenação simples que criaa matriz classificada final (ou lista) um item de cada vez.
7+
É muito menos eficiente em grandes listas do que mais algoritmos avançados, como quicksort, heapsort ou merge
8+
ordenar.
9+
10+
![Visualização do Algoritmo](https://upload.wikimedia.org/wikipedia/commons/4/42/Insertion_sort.gif)
11+
12+
![Visualização do Algoritmo](https://upload.wikimedia.org/wikipedia/commons/0/0f/Insertion-sort-example-300px.gif)
13+
14+
## Complexidade
15+
16+
| Nome | Melhor | Média | Pior | Memória | Estável | Comentários |
17+
| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
18+
| **Insertion sort** | n | n<sup>2</sup> | n<sup>2</sup> | 1 | Sim | |
19+
20+
## Referências
21+
22+
[Wikipedia](https://en.wikipedia.org/wiki/Insertion_sort)

‎src/algorithms/sorting/merge-sort/README.md

+2-1
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,8 @@
11
# Merge Sort
22

33
_Read this in other languages:_
4-
[_한국어_](README.ko-KR.md)
4+
[_한국어_](README.ko-KR.md),
5+
[_Português_](README.pt-BR.md)
56

67
In computer science, merge sort (also commonly spelled
78
mergesort) is an efficient, general-purpose,

‎src/algorithms/sorting/merge-sort/README.pt-BR.md

+38
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,38 @@
1+
# Merge Sort
2+
3+
_Leia isso em outros idiomas:_
4+
[_한국어_](README.ko-KR.md),
5+
[_English_](README.md)
6+
7+
Em ciência da computação, merge sort (também comumente escrito
8+
mergesort) é uma ferramenta eficiente, de propósito geral,
9+
algoritmo de ordenação baseado em comparação. A maioria das implementações
10+
produzir uma classificação estável, o que significa que a implementação
11+
preserva a ordem de entrada de elementos iguais na ordenação
12+
resultado. Mergesort é um algoritmo de divisão e conquista que
13+
foi inventado por John von Neumann em 1945.
14+
15+
Um exemplo de classificação de mesclagem. Primeiro divida a lista em
16+
a menor unidade (1 elemento), então compare cada
17+
elemento com a lista adjacente para classificar e mesclar o
18+
duas listas adjacentes. Finalmente todos os elementos são ordenados
19+
e mesclado.
20+
21+
![Merge Sort](https://upload.wikimedia.org/wikipedia/commons/c/cc/Merge-sort-example-300px.gif)
22+
23+
Um algoritmo de classificação de mesclagem recursivo usado para classificar uma matriz de 7
24+
valores inteiros. Estes são os passos que um ser humano daria para
25+
emular merge sort (top-down).
26+
27+
![Merge Sort](https://upload.wikimedia.org/wikipedia/commons/e/e6/Merge_sort_algorithm_diagram.svg)
28+
29+
## Complexidade
30+
31+
| Nome | Melhor | Média | Pior | Memória | Estável | Comentários |
32+
| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
33+
| **Merge sort** | n&nbsp;log(n) | n&nbsp;log(n) | n&nbsp;log(n) | n | Sim | |
34+
35+
## Referências
36+
37+
- [Wikipedia](https://en.wikipedia.org/wiki/Merge_sort)
38+
- [YouTube](https://www.youtube.com/watch?v=KF2j-9iSf4Q&index=27&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)

‎src/algorithms/sorting/quick-sort/README.md

+2-2
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,8 @@
11
# Quicksort
22

33
_Read this in other languages:_
4-
[_Português_](README.pt-BR.md),
5-
[_简体中文_](README.zh-CN.md)
4+
[_简体中文_](README.zh-CN.md),
5+
[_Português_](README.pt-BR.md)
66

77
Quicksort is a divide and conquer algorithm.
88
Quicksort first divides a large array into two smaller

0 commit comments

Comments
 (0)
Please sign in to comment.