Add favicon

Author: jnonino

content/programming/data-structures/queues/index.en.md

@@ -39,58 +39,10 @@ The basic queue operations are:
 Like stacks, queues can be implemented using linked lists.
 Elements are added at the end and removed from the front by keeping references to both ends.
 
-```python
-class Node:
-  def __init__(self, value):
-    self.value = value
-    self.next = None
-
-
-class Queue:
-  def __init__(self):
-    self.front = None
-    self.end = None
-    self.size = 0
-
-  def enqueue(self, value):
-    new_node = Node(value)
-    if self.end is None:
-      self.end = new_node
-      self.front = new_node
-      return
-    self.end.next = new_node
-    self.end = new_node
-    self.size += 1
-
-  def dequeue(self):
-    if self.is_empty():
-      return None
-    value = self.front.value
-    self.front = self.front.next
-    if self.front is None:
-      self.end = None
-    self.size -= 1
-    return value
-
-  def peek(self):
-    if self.is_empty():
-      return None
-    return self.front.value
-
-  def is_empty(self):
-    return self.front is None  # Returns true if front is None
-
-  def __len__(self):
-    return self.size
-
-  def __str__(self):
-    values = []
-    current = self.front
-    while current:
-      values.append(str(current.value))
-      current = current.next
-    return "\n".join(values)
-```
+{{< codeimporter
+    url="https://raw.githubusercontent.com/learn-software-engineering/examples/main/programming/data_structures/queues.py"
+    type="python"
+    >}}
 
 ---
 

content/programming/data-structures/queues/index.es.md

@@ -39,58 +39,11 @@ Las operaciones básicas de una cola son:
 Al igual que las pilas, las colas se pueden implementar usando listas enlazadas.
 Se agrega al final y se saca del frente manteniendo referencias a ambos extremos.
 
-```python
-class Node:
-    def __init__(self, value):
-        self.value = value
-        self.next = None
-
-
-class Queue:
-    def __init__(self):
-        self.front = None
-        self.end = None
-        self.size = 0
-
-    def enqueue(self, value):
-        new_node = Node(value)
-        if self.end is None:
-            self.end = new_node
-            self.front = new_node
-            return
-        self.end.next = new_node
-        self.end = new_node
-        self.size += 1
-
-    def dequeue(self):
-        if self.is_empty():
-            return None
-        value = self.front.value
-        self.front = self.front.next
-        if self.front is None:
-            self.end = None
-        self.size -= 1
-        return value
-
-    def peek(self):
-        if self.is_empty():
-            return None
-        return self.front.value
-
-    def is_empty(self):
-        return self.front is None  # Returns true if front is None
-
-    def __len__(self):
-        return self.size
-
-    def __str__(self):
-        values = []
-        current = self.front
-        while current:
-            values.append(str(current.value))
-            current = current.next
-        return "\n".join(values)
-```
+{{< codeimporter
+    url="https://raw.githubusercontent.com/learn-software-engineering/examples/main/programming/data_structures/queues.py"
+    type="python"
+    >}}
+
 ---
 
 ## Ejemplos de uso

content/programming/data-structures/stacks/index.en.md

@@ -38,54 +38,10 @@ Most languages like Python and Java provide stack implementations in their stand
 
 A stack can be implemented using a linked list so that each node points to the previous node.
 
-```python
-class Node:
-  def __init__(self, value):
-    self.value = value
-    self.previous = None
-
-
-class Stack:
-  def __init__(self):
-    self.top = None
-    self.size = 0
-
-  def push(self, value):
-    new_node = Node(value)
-    if self.top is None:
-      self.top = new_node
-    else:
-      new_node.previous = self.top
-      self.top = new_node
-    self.size += 1
-
-  def pop(self):
-    if self.top is None:
-      return None
-    top_node = self.top
-    self.top = self.top.previous
-    self.size -= 1
-    return top_node.value
-
-  def peek(self):
-    if self.top is None:
-      return None
-    return self.top.value
-
-  def is_empty(self):
-    return self.top is None  # Returns true if top is None
-
-  def __len__(self):
-    return self.size
-
-  def __str__(self):
-    values = []
-    current = self.top
-    while current:
-      values.append(str(current.value))
-      current = current.previous
-    return "\n".join(values)
-```
+{{< codeimporter
+    url="https://raw.githubusercontent.com/learn-software-engineering/examples/main/programming/data_structures/stacks.py"
+    type="python"
+    >}}
 
 ---
 

content/programming/data-structures/stacks/index.es.md

@@ -38,54 +38,10 @@ La mayoría de los lenguajes como Python y Java proveen implementaciones de pila
 
 Una pila puede implementarse utilizando una lista enlazada de manera que cada node apunte al nodo anterior.
 
-```python
-class Node:
-    def __init__(self, value):
-        self.value = value
-        self.previous = None
-
-
-class Stack:
-    def __init__(self):
-        self.top = None
-        self.size = 0
-
-    def push(self, value):
-        new_node = Node(value)
-        if self.top is None:
-            self.top = new_node
-        else:
-            new_node.previous = self.top
-            self.top = new_node
-        self.size += 1
-
-    def pop(self):
-        if self.top is None:
-            return None
-        top_node = self.top
-        self.top = self.top.previous
-        self.size -= 1
-        return top_node.value
-
-    def peek(self):
-        if self.top is None:
-            return None
-        return self.top.value
-
-    def is_empty(self):
-        return self.top is None  # Returns true if top is None
-
-    def __len__(self):
-        return self.size
-
-    def __str__(self):
-        values = []
-        current = self.top
-        while current:
-            values.append(str(current.value))
-            current = current.previous
-        return "\n".join(values)
-```
+{{< codeimporter
+    url="https://raw.githubusercontent.com/learn-software-engineering/examples/main/programming/data_structures/stacks.py"
+    type="python"
+    >}}
 
 ---
 

content/programming/intro/setup-dev-environment/index.en.md

@@ -146,9 +146,10 @@ Once you've set up your programming environment, it's time to dive into coding.
 
 This is arguably the most iconic program for beginners. It's simple, but it introduces you to the process of writing and executing code.
 
-```python
-print("Hello, World!")
-```
+{{< codeimporter
+    url="https://raw.githubusercontent.com/learn-software-engineering/examples/main/programming/intro/hello_world.py"
+    type="python"
+    >}}
 
 {{< figure
     src="running-hello-world.en.png"
@@ -160,22 +161,10 @@ print("Hello, World!")
 
 This program is a tad more intricate. It doesn't just print out a message; it also performs mathematical calculations.
 
-```python
-# User input
-side1 = float(input("Enter the length of the first side: "))
-side2 = float(input("Enter the length of the second side: "))
-side3 = float(input("Enter the length of the third side: "))
-
-# Perimeter calculation
-perimeter = side1 + side2 + side3
-
-# Area calculation using Heron's formula
-s = perimeter / 2
-area = (s*(s-side1)*(s-side2)*(s-side3)) ** 0.5
-
-print(f"The triangle's perimeter is: {perimeter}")
-print(f"The triangle's area is: {area:.2f}")
-```
+{{< codeimporter
+    url="https://raw.githubusercontent.com/learn-software-engineering/examples/main/programming/intro/triangle.py"
+    type="python"
+    >}}
 
 {{< figure
     src="running-triangle.en.png"

content/programming/intro/setup-dev-environment/index.es.md

@@ -146,9 +146,10 @@ Una vez que hayas configurado tu entorno de programación, es hora de sumergirse
 
 Este es posiblemente el programa más icónico para principiantes. Es simple, pero te introduce al proceso de escribir y ejecutar código.
 
-```python
-print("¡Hola mundo!")
-```
+{{< codeimporter
+    url="https://raw.githubusercontent.com/learn-software-engineering/examples/main/programming/intro/hola_mundo.py"
+    type="python"
+    >}}
 
 {{< figure
     src="running-hello-world.es.png"
@@ -160,22 +161,10 @@ print("¡Hola mundo!")
 
 Este programa es un poco más complejo. No solo imprime un mensaje, sino que también realiza cálculos matemáticos.
 
-```python
-# Entrada del usuario
-lado1 = float(input("Introduce la longitud del primer lado: "))
-lado2 = float(input("Introduce la longitud del segundo lado: "))
-lado3 = float(input("Introduce la longitud del tercer lado: "))
-
-# Cálculo del perímetro
-perimetro = lado1 + lado2 + lado3
-
-# Cálculo del área usando la fórmula de Herón
-s = perimetro / 2
-area = (s*(s-lado1)*(s-lado2)*(s-lado3)) ** 0.5
-
-print(f"El perímetro del triángulo es: {perimetro}")
-print(f"El área del triángulo es: {area:.2f}")
-```
+{{< codeimporter
+    url="https://raw.githubusercontent.com/learn-software-engineering/examples/main/programming/intro/triangulo.py"
+    type="python"
+    >}}
 
 {{< figure
     src="running-triangle.es.png"