Aplanar listas anidadas arbitrariamente (Recursión)

Este es el seguimiento avanzado de Aplanar un arreglo 2D. Practica primero ese desafío. Aquí las listas pueden contener más listas a cualquier profundidad. En C++ y C#, utiliza el tipo NestedValue provisto en el código inicial. Lee el campo kind primero: 0 significa omitir esta entrada, 1 significa agregar el valor, y 2 significa visitar los elementos recursivamente.

Convierte una lista anidada en una lista plana de enteros. Lee de izquierda a derecha; cada vez que encuentres otra lista, lee su contenido antes de continuar. Ignora los valores nulos (mostrados como None en los ejemplos) y las listas vacías. Conserva los enteros repetidos y su orden.

Python recibe listas anidadas ordinarias que contienen enteros y None. C++ y C# reciben una lista de objetos NestedValue provistos por el código inicial: kind 0 significa nulo, kind 1 significa entero en value, y kind 2 significa una lista en items. Solo importa el campo seleccionado por kind. Devuelve una lista simple de enteros en todos los lenguajes.

Implementa flatten_arbitrarily_nested_list(values).

Entrada

values: Una lista cuyas entradas pueden ser enteros, nulos o más listas.

Salida

Devuelve los enteros en orden de profundidad primero, de izquierda a derecha. Devuelve una lista vacía si no hay enteros.

Restricciones

El valor externo es una lista. Como máximo 10,000 entradas sumando todas las listas; profundidad máxima de anidamiento 50. Las hojas enteras caben en un entero con signo de 64 bits. Las hojas son enteros o nulos, nunca cadenas ni booleanos.

Ejemplos

Ejemplo 1

Entrada:
values = [
    1,
    [
        2,
        None,
        [3]
    ],
    [],
    4
]

Salida esperada:
[1, 2, 3, 4]

Explicación

Lee 1, luego entra en la lista anidada y lee 2 y 3, omitiendo el nulo. La lista vacía no agrega nada; termina con 4.

Ejemplo 2

Entrada:
values = [
    None,
    [],
    [None]
]

Salida esperada:
[]

Explicación

Cada entrada es nula o un contenedor vacío. No queda ningún entero.

Referencias

Exercism: Flatten Array

Ejecuta las pruebas de ejemplo para verificar tu código sin enviarlo.

Example 1 Sin ejecutar

Entrada:

values = [
    1,
    [
        2,
        None,
        [3]
    ],
    [],
    4
]

Salida esperada:

[1, 2, 3, 4]

Tu salida

Example 2 Sin ejecutar
Entrada:
```
values = [
    None,
    [],
    [None]
]
```
Salida esperada:
```
[]
```
Tu salida

5 pruebas ocultas también se ejecutan al enviar.

Compilador y depurador C++ online

Compila y depura C++ con puntos de interrupción, variables y pasos de GDB en modo Servidor.

Versión

Bibliotecas preinstaladas

🚀 2,389,463 ejecuciones totales (98,068 este mes)

Salida

Find the shortest piece of text containing all required characters.

AdvancedCompetitive-programmingSliding-windowStrings

Aún no hay soluciones

Explorar por tema

Aprende C y C++ juntos con código práctico, resultados, memoria, estructuras de datos, algoritmos y C++ moderno.

Ejemplos de C/C++ →

💻 Acerca de este ejecutor de C++ en línea

El Ejecutor de C++ de CodeUtility te permite escribir y ejecutar código C++ directamente en tu navegador - sin instalación ni configuración de compilador. Funciona con una sandbox segura que admite estándares reales de C++ desde C++11, C++14, C++17, hasta la última versión.

Esta herramienta usa un compilador C++ real en la nube para compilar y ejecutar tu código, garantizando un comportamiento preciso y consistente entre versiones. Puedes experimentar libremente con conceptos básicos de C++ como variables, funciones, bucles, condicionales y programación orientada a objetos.

Ya sea que te estés preparando para entrevistas, aprendiendo funciones modernas de C++ o verificando la lógica de algoritmos, el Ejecutor de C++ de CodeUtility ofrece un entorno simple pero potente para ejecutar código al instante desde cualquier dispositivo.

Más que un ejecutor de código

Utiliza un editor de varios archivos, un terminal de ejecución aislado, bibliotecas específicas del entorno, espacios de trabajo persistentes, opciones para compartir y colaboración en tiempo real desde el mismo ejecutor.

¿Cómo se utiliza este ejecutor?

Elige un entorno de ejecución, abre o crea un archivo, escribe el código y selecciona Ejecutar. El resultado aparece en el terminal; los usuarios que han iniciado sesión pueden conservar archivos en un espacio de trabajo, instalar bibliotecas y colaborar mediante elementos compartidos.

Selecciona una versión y edita el archivo actual o abre otro archivo del espacio de trabajo.
Ejecuta el código, introduce datos en el terminal cuando se soliciten y revisa el historial de ejecuciones guardado.
Utiliza bibliotecas, herramientas del espacio de trabajo, opciones para compartir y el chat cuando la tarea requiera más de un fragmento.

Empezar a codificar

VersiónSeleccione un tiempo de ejecución antes de ejecutar.Las bibliotecas instaladas pertenecen a la versión del idioma seleccionado.
Archivos abiertos enumera archivos de texto no abiertos.Seleccione uno para abrirlo en una pestaña del editor disponible.
Ejecutar ejecuta el archivo activo con su espacio de trabajo disponible para el programa.
Stop finaliza la ejecución actual antes de su límite de tiempo.
El modo avanzado abre el diseño IDE con un explorador de archivos y un terminal móvil de tamaño variable.

Espacio de trabajo y bibliotecas

Nuevo archivo crea un archivo en el directorio principal seleccionado y lo abre en el editor.
La nueva carpeta crea un directorio, hasta la profundidad de anidamiento admitida.
Cargar archivos agrega uno o más archivos seguros a un directorio.
La descarga guarda un archivo o un directorio comprimido en su dispositivo.
Copiar duplica un archivo o directorio de espacio de trabajo.
Cambiar nombre cambia el nombre de un archivo y actualiza su pestaña abierta y su historial.
Mover reubica un elemento;También se pueden arrastrar archivos y directorios.
Eliminar elimina un elemento después de la confirmación y cierra la pestaña abierta del editor.
Las bibliotecas preinstaladas muestran los paquetes que ya están incluidos en este tiempo de ejecución.
Add Lib instala un paquete privado para su cuenta y el tiempo de ejecución seleccionado.

Terminal y asistencia

El historial de ejecución abre las salidas guardadas anteriores y siguientes.
Ejecutar con cambia C++ entre el servidor de ejecución y C++ en el navegador. El modo de navegador sincroniza los archivos del espacio de trabajo; las bibliotecas instaladas en la cuenta y la entrada interactiva requieren el servidor de ejecución.
Copiar salida copia el texto del terminal actual.
Borrar salida elimina todas las salidas de ejecución guardadas después de la confirmación.
Explicar resume el código activo.
Recientes abre explicaciones y resultados recientes.
La configuración cambia las fuentes, los temas y los botones visibles de la barra de herramientas.

Compartir y colaborar

Share publica el archivo actual, un directorio o todo el espacio de trabajo como una instantánea o un espacio de trabajo en vivo.Usted controla el acceso a los enlaces y quién puede guardar los cambios.
Registra las acciones guardadas de los colaboradores en un espacio de trabajo compartido.
Compartir chat permite a los participantes que han iniciado sesión enviar mensajes, mencionar personas, compartir bloques de código y ver miembros en línea o escribiendo.
La colaboración en vivo muestra los cursores de los colaboradores y las actualizaciones de archivos guardados.Los usuarios de solo lectura pueden cargar la última versión o mantener ediciones temporales.

Cuotas y límites

El tiempo de ejecución está limitado a 20 segundos por ejecución del servidor.Utilice Detener cuando desee finalizarlo antes.
El almacenamiento del espacio de trabajo permite 100 archivos, 100 directorios y 10 MiB en total para cada espacio de trabajo e idioma de usuario que haya iniciado sesión.
Los archivos y carpetas están limitados a 1 MiB por archivo y 5 niveles de directorio anidados.Los archivos generados por su código siguen la misma cuota.
Las bibliotecas privadas están limitadas a 10 paquetes instalados para cada cuenta y tiempo de ejecución.
Las instantáneas compartidas pueden contener hasta 100 archivos, 1 MiB por archivo y 2 MiB en total.
Las invitaciones para compartir admiten hasta 25 personas por acción, con permisos de acceso y guardado administrados por separado.
El chat compartido permite 2000 caracteres por mensaje y 10 000 mensajes por compartir.
La aplicación de cuotas también se aplica mientras se ejecuta el código.Una escritura que exceda los límites de recuento, tamaño, almacenamiento o anidamiento de archivos se rechaza de forma segura.

Es bueno saberlo Sólo ejecute código e instale paquetes en los que confíe.La ejecución es aislada y limitada, pero su programa aún puede modificar archivos dentro de un espacio de trabajo de escritura hasta su cuota impuesta.

💡 Conceptos básicos de C++ y ejemplos que puedes probar arriba

1. Declaración de variables y constantes

C++ requiere declarar el tipo de cada variable. Usa const para definir valores de solo lectura que no pueden cambiarse después de la inicialización.

int age = 30;
double pi = 3.14159;
char grade = 'A';
std::string name = "Alice";
bool isActive = true;

// Constantes
const int MAX_USERS = 100;
const std::string COMPANY = "CodeUtility";

// Intentar modificar un const provocará un error en tiempo de compilación
// MAX_USERS = 200; // ❌ error

2. Condicionales (if / switch)

Usa if, else if, else para ramificar. Usa switch para múltiples valores.

int x = 2;
if (x == 1) {
    std::cout << "Uno\n";
} else if (x == 2) {
    std::cout << "Dos\n";
} else {
    std::cout << "Otro\n";
}

// Switch-case
switch (x) {
    case 1:
        std::cout << "Uno\n";
        break;
    case 2:
        std::cout << "Dos\n";
        break;
    default:
        std::cout << "Otro\n";
}

3. Bucles

Usa for, while y do-while para repetir bloques de código.

for (int i = 0; i < 3; i++) {
    std::cout << i << "\n";
}

int n = 3;
while (n > 0) {
    std::cout << n << "\n";
    n--;
}

4. Arreglos

Los arreglos almacenan múltiples elementos del mismo tipo.

int numbers[3] = {10, 20, 30};
std::cout << numbers[1] << "\n";

5. Manipulación de arreglos/vectores

Usa std::vector para arreglos dinámicos.

#include <vector>

std::vector nums = {1, 2, 3};
nums.push_back(4);
nums.pop_back();

for (int n : nums) {
    std::cout << n << " ";
}

6. Entrada/Salida por consola

Usa std::cin para entrada y std::cout para salida.

std::string name;
std::cout << "Ingresa tu nombre: ";
std::cin >> name;
std::cout << "Hola, " << name << "\n";

7. Funciones

Las funciones agrupan lógica reutilizable. Usa parámetros y tipos de retorno.

int add(int a, int b) {
    return a + b;
}

std::cout << add(3, 4);

8. Mapas

std::map almacena pares clave-valor como diccionarios.

#include <map>

std::map ages;
ages["Alice"] = 30;
std::cout << ages["Alice"];

9. Manejo de excepciones

Usa try y catch para manejar errores en tiempo de ejecución.

try {
    throw std::runtime_error("Ocurrió un error");
} catch (const std::exception& e) {
    std::cout << e.what();
}

10. E/S de archivos

Usa fstream para leer y escribir archivos.

#include <fstream>

std::ofstream out("file.txt");
out << "Hola archivo";
out.close();

std::ifstream in("file.txt");
std::string line;
getline(in, line);
std::cout << line;
in.close();

11. Manipulación de cadenas

Las cadenas de C++ admiten métodos como length(), substr() y find().

std::string text = "Hola Mundo";
std::cout << text.length();
std::cout << text.substr(0, 5);
std::cout << text.find("Mundo");

12. Clases y objetos

C++ admite programación orientada a objetos mediante clases.

class Person {
  public:
    std::string name;
    Person(std::string n) : name(n) {}
    void greet() { std::cout << "Hola, soy " << name; }
};

Person p("Alice");
p.greet();

13. Punteros

Un puntero almacena la dirección de memoria de otra variable. Usa & para obtener una dirección, y * para desreferenciar (acceder al valor en esa dirección).

int x = 10;
int* ptr = &x;

std::cout << "Valor de x: " << x << "\n";
std::cout << "Dirección de x: " << ptr << "\n";
std::cout << "Valor desde el puntero: " << *ptr << "\n";

// Modifica x mediante el puntero
*ptr = 20;
std::cout << "x actualizada: " << x << "\n";

🐞 Cómo depurar código %{language} online

Usa el depurador %{language} online para encontrar errores de ejecución y lógica sin instalar un compilador o IDE. El modo Servidor compila con símbolos de depuración y ejecuta el programa con GDB.

Añade puntos de interrupción junto a los números de línea.
Selecciona Depurar para compilar y pausar en el primer punto coincidente.
Inspecciona la línea, la pila de llamadas y las variables.
Usa Continuar, Paso por encima, Paso a paso o Salir.
Selecciona Detener para finalizar la sesión.

Empieza con un ejemplo mínimo reproducible y coloca el punto de interrupción antes del comportamiento inesperado.