Skip to content

Commit 302ded9

Browse files
lauchimoonlauchimoon
authored
Add Spanish translations for learn-c.org (ronreiter#709)
There are some missing but I'm sending these so far. I will be completing the rest once these are accepted :)
1 parent d061773 commit 302ded9

13 files changed

+1381
-0
lines changed

‎tutorials/learn-c.org/es/Arrays.md

Lines changed: 81 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,81 @@
1+
Tutorial
2+
--------
3+
4+
Los arreglos son variables especiales los cuales pueden sostener más de un valor bajo el mismo nombre de variable, organizado con un índice. Los arreglos son definidos usando una
5+
sintáxis muy directa:
6+
7+
/* define un arreglo de 10 enteros */
8+
int numbers[10];
9+
10+
Para acceder a un número del arreglo se usa la misma sintáxis. Nótese que los arreglos en C empiezan en 0, lo cual significa que si
11+
definimos un arreglo de tamaño 10, entonces se definen las celdas de 0 a 9 (inclusive). `numbers[10]` no es un valor.
12+
13+
int numbers[10];
14+
15+
/* popular el arreglo */
16+
numbers[0] = 10;
17+
numbers[1] = 20;
18+
numbers[2] = 30;
19+
numbers[3] = 40;
20+
numbers[4] = 50;
21+
numbers[5] = 60;
22+
numbers[6] = 70;
23+
24+
/* imprime el 7mo número del arreglo, el cual tiene un índice de 6 */
25+
printf("El 7mo número en el arreglo es %d", numbers[6]);
26+
27+
Los arreglos pueden tener un solo tipo de variable, porque son implementados como una secuencia de valores en la memoria de la computadora.
28+
Por eso, acceder una celda específica del arreglo es muy eficiente.
29+
30+
Ejercicio
31+
--------
32+
33+
* El código de abajo no compila, ya que no existe la variable `grades`.
34+
* Falta una de las calificaciones. ¿Puedes definirla así el promedio de calificaciones sea 85?
35+
36+
Tutorial Code
37+
-------------
38+
39+
#include <stdio.h>
40+
41+
int main() {
42+
/* TODO: define la variable grades aquí */
43+
int average;
44+
45+
grades[0] = 80;
46+
/* TODO: define la calificación faltante
47+
así el promedio suma 85. */
48+
grades[2] = 90;
49+
50+
average = (grades[0] + grades[1] + grades[2]) / 3;
51+
printf("El promedio de las 3 calificaciones es: %d", average);
52+
53+
return 0;
54+
}
55+
56+
Expected Output
57+
---------------
58+
59+
El promedio de las 3 calificaciones es: 85
60+
61+
Solution
62+
--------
63+
64+
#include <stdio.h>
65+
66+
int main() {
67+
/* TODO: define la variable grades aquí */
68+
int grades[3];
69+
int average;
70+
71+
grades[0] = 80;
72+
/* TODO: define la calificación faltante
73+
así el promedio suma 85. */
74+
grades[1] = 85;
75+
grades[2] = 90;
76+
77+
average = (grades[0] + grades[1] + grades[2]) / 3;
78+
printf("El promedio de las 3 calificaciones es: %d", average);
79+
80+
return 0;
81+
}

‎tutorials/learn-c.org/es/Binary trees.md

Lines changed: 211 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,211 @@
1+
Tutorial
2+
--------
3+
4+
### Introducción
5+
6+
Un Árbol Binario es un tipo de estructura de datos donde cada nodo tiene por lo menos dos hijos (hijo izquierdo e hijo derecho). Los Árboles Binarios son usados para implementar árboles de busqueda binaria, y son usados para buscar y ordenar eficientemente. Un árbol binario es un caso especial de un árbol K-ario, donde K es 2. Algunas operaciones para los árboles binarios incluyen inserción, supresión, y poder recorrerlos. La dificultad de realizar estas operaciones va a depender de si el árbol está balanceado y si los nodos son nodos hijos o nodos padres. Para un **árbol balanceado** el profundo de los nodos de los subárboles izquierdos y derechos difieren por 1 o menos. Esto permite una **profundidad** predecible también conocida como **altura**. Esta es la medida de raíz a hoja (padre e hijo), donde la raíz es 0 y los nodos siguientes son (1,2..n). Esto puede ser expresado como la parte entera de log<sub>2</sub>(n) donde n es el número de nodos en el árbol.
7+
8+
g s 9
9+
/ \ / \ / \
10+
b m f u 5 13
11+
/ \ / \ / \
12+
c d t y 11 15
13+
14+
Las operaciones realizadas requieren buscar en una de dos maneras principales: Búsqueda de "Profundidad Primero" y Búsqueda de "Amplitud Primero". **Depth-first search (DFS, Profunidad Primero)** es un algoritmo para recorrer o buscar en estructuras de árboles o gráficos de datos. Uno empieza en la raíz y explora tan lejos como puede entre cada rama antes de volver atrás. Hay tres tipos de recorrido en este tipo de búsqueda: **pre orden** visita, izquierda, derecha, **en orden** izquierda, visita, derecha, **post orden** izquierda, derecha, visita. **Breadth-first search (BFS, Amplitud Primero)** es un algoritmo para recorrer y buscar estructuras de árboles o gráficos. En orden de nivel, donde visitamos cada nodo en un nivel antes de ir a un nivel más bajo.<br>
15+
16+
17+
Ejercicio
18+
--------
19+
20+
Debajo hay una implementación de un árbol binario que tiene capacidades de imprimirse e insertar elementos en él. Este árbol está ordenado pero no balanceado. Este ejemplo mantiene su orden a la hora de insertar.
21+
22+
Cambia la rutina de impresión a búsqueda de profundidad primero con **pre orden**.
23+
24+
25+
Tutorial Code
26+
-------------
27+
28+
#include <stdio.h>
29+
#include <stdlib.h>
30+
31+
typedef struct node
32+
{
33+
int val;
34+
struct node * left;
35+
struct node * right;
36+
} node_t;
37+
38+
void insert(node_t * tree,int val);
39+
void print_tree(node_t * current);
40+
void printDFS(node_t * current);
41+
42+
int main()
43+
{
44+
node_t * test_list = (node_t *) malloc(sizeof(node_t));
45+
/* definir los valores explicitamente, una alternativa sería usar calloc() */
46+
test_list->val = 0;
47+
test_list->left = NULL;
48+
test_list->right = NULL;
49+
50+
insert(test_list,5);
51+
insert(test_list,8);
52+
insert(test_list,4);
53+
insert(test_list,3);
54+
55+
printDFS(test_list);
56+
printf("\n");
57+
}
58+
59+
void insert(node_t * tree, int val)
60+
{
61+
if (tree->val == 0)
62+
{
63+
/* insertar en la posición (vacía) actual */
64+
tree->val = val;
65+
}
66+
else
67+
{
68+
if (val < tree->val)
69+
{
70+
/* insertar izquierda */
71+
if (tree->left != NULL)
72+
{
73+
insert(tree->left, val);
74+
}
75+
else
76+
{
77+
tree->left = (node_t *) malloc(sizeof(node_t));
78+
/* definir los valores explicitamente, una alternativa sería usar calloc() */
79+
tree->left->val = val;
80+
tree->left->left = NULL;
81+
tree->left->right = NULL;
82+
}
83+
}
84+
else
85+
{
86+
if (val >= tree->val)
87+
{
88+
/* insertar derecha */
89+
if (tree->right != NULL)
90+
{
91+
insert(tree->right,val);
92+
}
93+
else
94+
{
95+
tree->right = (node_t *) malloc(sizeof(node_t));
96+
/* definir los valores explicitamente, una alternativa sería usar calloc() */
97+
tree->right->val = val;
98+
tree->right->left = NULL;
99+
tree->right->right = NULL;
100+
}
101+
}
102+
}
103+
}
104+
}
105+
106+
/* búsqueda de profundidad primero */
107+
void printDFS(node_t * current)
108+
{
109+
/* cambia el código aquí */
110+
if (current == NULL) return; /* medida de seguridad */
111+
if (current->left != NULL) printDFS(current->left);
112+
if (current != NULL) printf("%d ", current->val);
113+
if (current->right != NULL) printDFS(current->right);
114+
}
115+
116+
117+
Expected Output
118+
---------------
119+
120+
5 4 3 8
121+
122+
Solution
123+
--------
124+
125+
#include <stdio.h>
126+
#include <stdlib.h>
127+
128+
typedef struct node
129+
{
130+
int val;
131+
struct node * left;
132+
struct node * right;
133+
} node_t;
134+
135+
void insert(node_t * tree,int val);
136+
void print_tree(node_t * current);
137+
void printDFS(node_t * current);
138+
139+
int main()
140+
{
141+
node_t * test_list = (node_t *) malloc(sizeof(node_t));
142+
/* definir los valores explicitamente, una alternativa sería usar calloc() */
143+
test_list->val = 0;
144+
test_list->left = NULL;
145+
test_list->right = NULL;
146+
147+
insert(test_list,5);
148+
insert(test_list,8);
149+
insert(test_list,4);
150+
insert(test_list,3);
151+
152+
printDFS(test_list);
153+
printf("\n");
154+
}
155+
156+
void insert(node_t * tree, int val)
157+
{
158+
if (tree->val == 0)
159+
{
160+
/* insertar en la posición (vacía) actual */
161+
tree->val = val;
162+
}
163+
else
164+
{
165+
if (val < tree->val)
166+
{
167+
/* insertar izquierda */
168+
if (tree->left != NULL)
169+
{
170+
insert(tree->left, val);
171+
}
172+
else
173+
{
174+
tree->left = (node_t *) malloc(sizeof(node_t));
175+
/* definir los valores explicitamente, una alternativa sería usar calloc() */
176+
tree->left->val = val;
177+
tree->left->left = NULL;
178+
tree->left->right = NULL;
179+
}
180+
}
181+
else
182+
{
183+
if (val >= tree->val)
184+
{
185+
/* insertar derecha */
186+
if (tree->right != NULL)
187+
{
188+
insert(tree->right,val);
189+
}
190+
else
191+
{
192+
tree->right = (node_t *) malloc(sizeof(node_t));
193+
/* definir los valores explicitamente, una alternativa sería usar calloc() */
194+
tree->right->val = val;
195+
tree->right->left = NULL;
196+
tree->right->right = NULL;
197+
}
198+
}
199+
}
200+
}
201+
}
202+
203+
/* búsqueda de profundidad primero */
204+
void printDFS(node_t * current)
205+
{
206+
/* cambia el código aquí */
207+
if (current == NULL) return; /* medida de seguridad */
208+
if (current != NULL) printf("%d ", current->val);
209+
if (current->left != NULL) printDFS(current->left);
210+
if (current->right != NULL) printDFS(current->right);
211+
}

0 commit comments

Comments
 (0)