Autocad plano departamento

plano de  departamento 

JAVA: FUNCIONES

 FUNCIONES

Las funciones en Java, conocidas técnicamente como métodos, son bloques de código reutilizables que realizan una tarea específica. Se definen dentro de una clase, pueden recibir parámetros (entradas), ejecutar instrucciones y opcionalmente retornar un valor usando la palabra clave 

 Sintaxis

tipoDeRetorno nombreMetodo(tipo param1, tipo param2) {

// código a ejecutar

return valor;  // opcional}

ejemplos:

1)saludar:

public class Ejemplo1 {

    static void saludar() {

        System.out.println("¡Hola, mundo!");

    }

    public static void main(String[] args) {

        saludar();  // Imprime: ¡Hola, mundo!

    }

}

2)suma de dos números

public class Ejemplo2 {

    static int sumar(int a, int b) {

        return a + b;

    }

    public static void main(String[] args) {

        int resultado = sumar(5, 3);  // resultado = 8

        System.out.println(resultado);

    }

}

void es una palabra clave en Java que indica que un método no devuelve ningún valor al terminar; solo ejecuta acciones como imprimir o modificar datos. return, por su parte, se usa en métodos no-void para devolver un valor específico al código que lo llamó, o en métodos void solo para salir prematuramente sin valor.

Ejemplos:

Ejemplo de función void:

public class EjemploVoid {

    static void saludar(String nombre) {

        System.out.println("Hola, " + nombre + "!");

        // No retorna nada

    }

    public static void main(String[] args) {

        saludar("Juan");  // Imprime: Hola, Juan!

    }

}

Ejemplo de return:

public class EjemploReturn {

    static int sumar(int a, int b) {

        return a + b;  // Devuelve la suma

    }

    public static void main(String[] args) {

        int resultado = sumar(5, 3);  // resultado = 8

        System.out.println(resultado);

    }

}

C# PILAS Y COLAS

 PILAS

 

Las pilas (Stack<T>) en C# son colecciones genéricas que siguen el principio LIFO (Last In, First Out), donde el último elemento en entrar es el primero en salir. Se definen en System.Collections.Generic, permitiendo añadir (Push), eliminar (Pop) y mirar (Peek) elementos eficientemente en tiempo

, ideales para deshacer acciones o recursividad.

bravedeveloper.com

bravedeveloper.com

 +4

Características y Operaciones Principales:

LIFO: El elemento en la cima es el primero en salir.

Push(T item): Añade un elemento a la parte superior.

Pop(): Elimina y devuelve el elemento superior.

Peek(): Devuelve el elemento superior sin eliminarlo.

Count: Obtiene el número de elementos.

Clear(): Elimina todos los elementos.

CODIGO:

using System;

 

// 1. CLASE NODO - Igual que en la cola

public class Nodo

{

    public int dato;

    public Nodo siguiente;

 

    public Nodo(int valor)

    {

        dato = valor;

        siguiente = null;

    }

}

 

// 2. CLASE PILA - Solo necesita UN puntero

public class PilaSimple

{

    private Nodo cima;  // Único puntero necesario (topo de la pila)

 

    // 3. CONSTRUCTOR

    public PilaSimple()

    {

        cima = null;    // Pila vacía

    }

 

    // 4. PUSH - Agrega a la CIMA ✓ O(1)

    public void Push(int valor)

    {

        Nodo nuevo = new Nodo(valor);    // Nuevo nodo

        nuevo.siguiente = cima;          // Apunta a la cima anterior

        cima = nuevo;                    // Nuevo nodo es la nueva cima

    }

 

    // 5. POP - Quita de la CIMA ✓ O(1)

    public int Pop()

    {

        if (cima == null)

        {

            Console.WriteLine("Pila vacía");

            return -1;

        }

 

        int valor = cima.dato;          // Guardar valor de la cima

        cima = cima.siguiente;          // Bajar una posición

        return valor;                   // Devolver elemento quitado

    }

 

    // 6. PEEK - Ver cima sin quitar

    public int Peek()

    {

        if (cima == null)

        {

            Console.WriteLine("Pila vacía");

            return -1;

        }

        return cima.dato;

    }

 

    // 7. MOSTRAR - De cima hacia abajo

    public void Mostrar()

    {

        Nodo actual = cima;

        Console.Write("Pila: ");

       

        while (actual != null)

        {

            Console.Write(actual.dato + " ← ");

            actual = actual.siguiente;

        }

        Console.WriteLine("null");

    }

}

 

// 8. PRUEBA

class Program

{

    static void Main()

    {

        PilaSimple pila = new PilaSimple();

       

        pila.Push(10);

        pila.Push(20);

        pila.Push(30);

        pila.Mostrar();  // Pila: 30 ← 20 ← 10 ← null

 

        pila.Pop();      // Quita 30

        pila.Mostrar();  // Pila: 20 ← 10 ← null

    }

}

 

APLICACIÓN DE COLAS

CLASE NODO:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

 

namespace SISTEMA_DE_COLAS

{

    public class Nodo

    {

        public int dato;

        public Nodo siguiente;

 

        public Nodo(int valor)

        {

            dato = valor;

            siguiente = null;

        }

    }

 

}

CLASE COLAS:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

 

namespace SISTEMA_DE_COLAS

{

    public class Cola

    {

        private Nodo inicio;

        private Nodo fin;

        private int tamaño;

 

        public Cola()

        {

            inicio = null;

            fin = null;

            tamaño = 0;

        }

 

        public void Encolar(int valor)

        {

            Nodo nuevo = new Nodo(valor);

            if (estaVacia())

            {

                inicio = nuevo;

                fin = nuevo;

            }

            else

            {

                fin.siguiente = nuevo;

                fin = nuevo;

            }

            tamaño++;

        }

 

        public int Desencolar()

        {

            if (estaVacia())

            {

                System.Windows.Forms.MessageBox.Show("¡La cola está vacía!");

                return -1;

            }

            int valor = inicio.dato;

            inicio = inicio.siguiente;

            if (inicio == null) fin = null;

            tamaño--;

            return valor;

        }

 

        public int Peek()

        {

            if (estaVacia())

            {

                System.Windows.Forms.MessageBox.Show("¡La cola está vacía!");

                return -1;

            }

            return inicio.dato;

        }

 

        public bool estaVacia() => inicio == null;

        public int Tamano() => tamaño;

 

        public string Mostrar()

        {

            if (estaVacia()) return "Cola vacía";

 

            System.Text.StringBuilder sb = new System.Text.StringBuilder();

            Nodo actual = inicio;

            while (actual != null)

            {

                sb.Append(actual.dato + " ");

                actual = actual.siguiente;

            }

            return sb.ToString().Trim();

        }

    }

 

}

FORM1:

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Forms;

 

namespace SISTEMA_DE_COLAS

{

    public partial class Form1 : Form

    {

        private Cola miCola;  // ← Esta línea es OBLIGATORIA

 

        public Form1()

        {

            InitializeComponent();

            miCola = new Cola();  // Inicializar la cola

            ActualizarInterfaz();

        }

 

        private void btnEncolar_Click(object sender, EventArgs e)

        {

            if (int.TryParse(txtNumero.Text, out int numero))

            {

                miCola.Encolar(numero);  // Ahora sí reconoce miCola

                txtNumero.Clear();

                ActualizarInterfaz();

            }

            else

            {

                MessageBox.Show("¡Ingrese un número válido!");

            }

        }

 

        private void btnDesencolar_Click(object sender, EventArgs e)

        {

            int resultado = miCola.Desencolar();

            if (resultado != -1)

            {

                MessageBox.Show($"Elemento removido: {resultado}");

                ActualizarInterfaz();

            }

        }

 

        private void btnPeek_Click(object sender, EventArgs e)

        {

            int primero = miCola.Peek();

            if (primero != -1)

            {

                MessageBox.Show($"Primer elemento: {primero}");

            }

        }

 

        private void btnLimpiar_Click(object sender, EventArgs e)

        {

            miCola = new Cola();  // Reinicia la cola

            ActualizarInterfaz();

        }

        private void ActualizarInterfaz()

        {

            lstCola.Items.Clear();

            lstCola.Items.Add(miCola.Mostrar());

            lblTamano.Text = $"Tamaño: {miCola.Tamano()}";

            txtNumero.Focus();

        }

    }

}

 

Autocad: cambio de ejes

CAMBIO DE EJES

EN INGLES: COMANDO UCS, VOLVER A EJES UNIVERSALES: WORLD

EN ESPAÑOL: COMANDO SCP, VOLVER A EJES UNIVERSALES: UNIVERSAL

CACTUS

LISTAS EN JAVA

LISTAS

                Una List en Java es una interfaz fundamental del framework de colecciones (java.util.List) que representa una secuencia ordenada de elementos (también conocida como colección ordenada). A diferencia de los arreglos tradicionales, las listas permiten almacenar elementos duplicados, valores nulos y gestionar el tamaño de manera dinámica, creciendo o disminuyendo automáticamente.

 

Características y detalles clave:

• Ordenada: Mantiene el orden de inserción, lo que significa que los elementos se pueden acceder por su posición (índice), empezando desde 0.
• Implementaciones comunes: Como es una interfaz, se utiliza a través de clases concretas, siendo las más populares ArrayList (para acceso rápido) y LinkedList (para inserciones/eliminaciones rápidas).
• Flexibilidad: Permite añadir, eliminar o modificar elementos en posiciones específicas.
• Seguridad de tipos: Utiliza genéricos (ej. List<String>), asegurando que solo se almacenen objetos del tipo especificado.

Ejemplo básico:

List<String> lista = new ArrayList<>();

lista.add("Elemento 1");

lista.add("Elemento 2");

System.out.println(lista.get(0)); // Salida: Elemento 1

 

CODIGO:

 

import java.util.ArrayList;

import java.util.List;

import java.util.Iterator;

 

    public class Listasejemplo {

    public static void main(String[] args) {

        // Crear una lista

        List<String> lista = new ArrayList<>();

       

        // 1. AGREGAR elementos

        lista.add("Manzana");

        lista.add("Banana");

        lista.add("Naranja");

        lista.add(1, "Pera"); // Agregar en posición específica

       

        System.out.println("Despues de agregar: " + lista);

       

        // 2. ACCEDER a elementos

        System.out.println("Elemento en posición 1: " + lista.get(1));

        System.out.println("Tamaño de la lista: " + lista.size());

       

        // 3. MODIFICAR elementos

        lista.set(2, "Kiwi");

        System.out.println("Despues de modificar: " + lista);

       

        // 4. ELIMINAR elementos

        lista.remove("Banana"); // Eliminar por valor

        lista.remove(0); // Eliminar por índice

        System.out.println("Después de eliminar: " + lista);

       

        // 5. BUSCAR elementos

        System.out.println("¿Contiene 'Kiwi'? " + lista.contains("Kiwi"));

        System.out.println("Índice de 'Pera': " + lista.indexOf("Pera"));

        System.out.println("¿Está vacía? " + lista.isEmpty());

       

        // 6. RECORRER la lista (varias formas)

        System.out.println("\n--- Recorrido con for-each ---");

        for (String fruta : lista) {

            System.out.println("- " + fruta);

        }

       

        System.out.println("\n--- Recorrido con Iterator ---");

        Iterator<String> it = lista.iterator();

        while (it.hasNext()) {

            System.out.println("- " + it.next());

        }

        System.out.println("recorrido con for");

        for(int i=0;i<lista.size();i++){

            System.out.println(lista.get(i));

        }

       

        // 7. LIMPIAR la lista

        lista.clear();

        System.out.println("Lista vacia: " + lista);

       

        // 8. Verificar si está vacia

        System.out.println("¿Está vacía ahora? " + lista.isEmpty());

    }

}

CODIGO 2: INGRESAR NUMEROS EN UNA LISTA Y HACER CALCULOS:

import java.util.ArrayList;

import java.util.List;

import java.util.Scanner;

 

public class ListaNumeros {

    public static void main(String[] args) {

        List<Integer> numeros = new ArrayList<>();

        Scanner sc = new Scanner(System.in);

       

        // 1. AGREGAR números

        System.out.print("¿Cuántos números? ");

        int cantidad = sc.nextInt();

       

        for(int i = 0; i < cantidad; i++) {

            System.out.print("Número " + (i+1) + ": ");

            numeros.add(sc.nextInt());

        }

       

        System.out.println("Lista: " + numeros);

       

        // 2. RECORRER con for clásico

        System.out.println("\n--- Recorrido con for clásico ---");

        for(int i = 0; i < numeros.size(); i++) {

            System.out.println("Posición " + i + ": " + numeros.get(i));

        }

       

        // 3. OPERACIONES con números

        int suma = 0;

        int maximo = numeros.get(0);

       

        // For-each para sumar y encontrar máximo

        for(int num : numeros) {

            suma += num;

            if(num > maximo) maximo = num;

        }

       

        System.out.println("\n--- Estadísticas ---");

        System.out.println("Suma: " + suma);

        System.out.println("Promedio: " + (suma * 1.0 / numeros.size()));

        System.out.println("Máximo: " + maximo);

       

        // 4. Buscar un número específico

        System.out.print("\n¿Buscar qué número? ");

        int buscar = sc.nextInt();

        int posicion = numeros.indexOf(buscar);

       

        if(posicion != -1) {

            System.out.println("Encontrado en posición: " + posicion);

        } else {

            System.out.println("Número NO encontrado");

        }

       

        sc.close();

    }

} 

C# LISTAS

LISTAS:

Una lista en C# es una colección dinámica de elementos del mismo tipo que crece automáticamente, a diferencia de los arrays que tienen tamaño fijo.

aracterísticas Principales

• Tipo genérico: List<string>, List<int>, List<Alumno>
• Espacio de nombres: using System.Collections.Generic;
• Acceso por índice: lista[0], lista[1]
• Propiedades: lista.Count (número de elementos)

CODIGO:

using System;

using System.Collections.Generic;

 

namespace Ejemplo

{

    internal class Program

    {

        static void Main(string[] args)

        {

            List<string> alumnos = new List<string>();  // Sin espacios extra

            alumnos.Add("pepe");

            alumnos.Add("joaquin");

            alumnos.Add("pepe");

            alumnos.Add("kimberly");

            alumnos.Add("eusebio");

            alumnos.Remove("eusebio");

            alumnos.Insert(1, "paola");

            Console.WriteLine(alumnos[0]);

            Console.WriteLine(alumnos.Count);

            Console.WriteLine(alumnos.IndexOf("joaquin"));

            Console.WriteLine(alumnos.LastIndexOf("pepe"));

            Console.WriteLine(alumnos.Contains("joaquin"));

            alumnos.Sort();

            alumnos.Reverse();

            //alumnos.Clear();

            string[] coleagiales=alumnos.ToArray();

 

 

 

            foreach (string alumn in alumnos)

            {

                Console.WriteLine(alumn);

            }

            Console.ReadKey();

            //ingreso de nombres:

            List<string> LIST2 = new List<string>();  // Tu lista LIST 2

            string dato;

 

            Console.WriteLine("=== LIST 2 ===");

            Console.Write("¿Cuántos datos ingresaras? ");

            int cantidad = int.Parse(Console.ReadLine());

 

            // Ingresar datos a LIST 2

            for (int i = 0; i < cantidad; i++)

            {

                Console.Write($"Dato {i + 1}: ");

                dato = Console.ReadLine();

                LIST2.Add(dato);  // Agregar a LIST 2

            }

 

            // Mostrar LIST 2

            Console.WriteLine("\nContenido de LIST 2:");

            for (int i = 0; i < LIST2.Count; i++)

            {

                Console.WriteLine($"[{i}] {LIST2[i]}");

            }

            Console.ReadKey();

        }

    }

}

   

Listas enlazadas

CODIGO:

using System;

 

// Clase Nodo que representa cada elemento de la lista

public class Nodo

{

    public int dato;        // Dato almacenado en el nodo

    public Nodo siguiente;  // Referencia al siguiente nodo

 

    public Nodo(int dato)

    {

        this.dato = dato;

        this.siguiente = null;

    }

}

 

// Clase ListaEnlazadaSimple que maneja todas las operaciones

public class ListaEnlazadaSimple

{

    private Nodo inicio;    // Puntero al primer nodo

 

    public ListaEnlazadaSimple()

    {

        inicio = null;

    }

 

    // 1. Insertar al inicio

    public void InsertarInicio(int dato)

    {

        Nodo nuevo = new Nodo(dato);

        nuevo.siguiente = inicio;

        inicio = nuevo;

    }

 

    // 2. Insertar al final

    public void InsertarFinal(int dato)

    {

        Nodo nuevo = new Nodo(dato);

 

        if (inicio == null)

        {

            inicio = nuevo;

            return;

        }

 

        Nodo actual = inicio;

        while (actual.siguiente != null)

        {

            actual = actual.siguiente;

        }

        actual.siguiente = nuevo;

    }

 

    // 3. Buscar un elemento

    public bool Buscar(int dato)

    {

        Nodo actual = inicio;

        while (actual != null)

        {

            if (actual.dato == dato)

                return true;

            actual = actual.siguiente;

        }

        return false;

    }

 

    // 4. Eliminar un elemento específico

    public bool Eliminar(int dato)

    {

        if (inicio == null)

            return false;

 

        // Si es el primer nodo

        if (inicio.dato == dato)

        {

            inicio = inicio.siguiente;

            return true;

        }

 

        // Buscar el nodo anterior al que se quiere eliminar

        Nodo actual = inicio;

        while (actual.siguiente != null)

        {

            if (actual.siguiente.dato == dato)

            {

                actual.siguiente = actual.siguiente.siguiente;

                return true;

            }

            actual = actual.siguiente;

        }

        return false;

    }

 

    // 5. Mostrar todos los elementos

    public void Mostrar()

    {

        if (inicio == null)

        {

            Console.WriteLine("La lista está vacía");

            return;

        }

 

        Nodo actual = inicio;

        Console.Write("Lista: ");

        while (actual != null)

        {

            Console.Write(actual.dato + " -> ");

            actual = actual.siguiente;

        }

        Console.WriteLine("NULL");

    }

 

    // 6. Obtener tamaño de la lista

    public int Tamano()

    {

        int count = 0;

        Nodo actual = inicio;

        while (actual != null)

        {

            count++;

            actual = actual.siguiente;

        }

        return count;

    }

 

    // 7. Verificar si está vacía

    public bool EstaVacia()

    {

        return inicio == null;

    }

}

 

// Programa principal para probar la lista

class Program

{

    static void Main(string[] args)

    {

        ListaEnlazadaSimple lista = new ListaEnlazadaSimple();

 

        Console.WriteLine("=== DEMOSTRACIÓN DE LISTA ENLAZADA SIMPLE ===\n");

 

        // Insertar al inicio

        lista.InsertarInicio(10);

        lista.InsertarInicio(20);

        lista.InsertarInicio(30);

        Console.WriteLine("1. Insertar al inicio (30,20,10):");

        lista.Mostrar();

 

        // Insertar al final

        lista.InsertarFinal(40);

        lista.InsertarFinal(50);

        Console.WriteLine("\n2. Insertar al final (agrega 40,50):");

        lista.Mostrar();

 

        // Buscar

        Console.WriteLine($"\n3. Buscar 40: {lista.Buscar(40)}");

        Console.WriteLine($"Buscar 100: {lista.Buscar(100)}");

 

        // Tamaño

        Console.WriteLine($"\n4. Tamaño de la lista: {lista.Tamano()}");

 

        // Eliminar

        Console.WriteLine("\n5. Eliminar 20:");

        lista.Eliminar(20);

        lista.Mostrar();

 

        Console.WriteLine($"\n6. ¿Está vacía? {lista.EstaVacia()}");

 

        Console.WriteLine("\nPresiona cualquier tecla para salir...");

        Console.ReadKey();

    }

}

 

PROGRAMA QUE INGRESA NODOS Y REPORTA LISTAS ENLAZADAS

using System;

 

public class Nodo

{

    public int dato;

    public Nodo siguiente;

 

    public Nodo(int dato)

    {

        this.dato = dato;

        this.siguiente = null;

    }

}

 

public class ListaSimple

{

    private Nodo inicio;

 

    public ListaSimple()

    {

        inicio = null;

    }

 

    // Insertar al final

    public void Agregar(int dato)

    {

        Nodo nuevo = new Nodo(dato);

        if (inicio == null)

        {

            inicio = nuevo;

            return;

        }

 

        Nodo actual = inicio;

        while (actual.siguiente != null)

        {

            actual = actual.siguiente;

        }

        actual.siguiente = nuevo;

    }

 

    // Imprimir todos los nodos

    public void Imprimir()

    {

        if (inicio == null)

        {

            Console.WriteLine("La lista está vacía");

            return;

        }

 

        Console.Write("Nodos: ");

        Nodo actual = inicio;

        while (actual != null)

        {

            Console.Write(actual.dato);

            if (actual.siguiente != null)

                Console.Write(" -> ");

            actual = actual.siguiente;

        }

        Console.WriteLine();

    }

}

 

class Program

{

    static void Main(string[] args)

    {

        ListaSimple lista = new ListaSimple();

        Console.WriteLine("=== LISTA ENLAZADA SIMPLE INTERACTIVA ===\n");

 

        // Ingresar datos

        Console.WriteLine("Ingresa números (0 para terminar):");

        int numero;

        do

        {

            Console.Write("Número: ");

            numero = int.Parse(Console.ReadLine());

            if (numero != 0)

            {

                lista.Agregar(numero);

            }

        } while (numero != 0);

 

        Console.WriteLine("\n--- RESULTADO ---");

        lista.Imprimir();

 

        Console.WriteLine("\nPresiona cualquier tecla para salir...");

        Console.ReadKey();

    }

}

 

COLAS

>using System;

 

// Clase Nodo para la estructura de la cola

public class Nodo

{

    public int dato;

    public Nodo siguiente;

   

    public Nodo(int valor)

    {

        dato = valor;

        siguiente = null;

    }

}

 

// Clase Cola que usa nodos enlazados

public class Cola

{

    private Nodo inicio;

    private Nodo fin;

   

    public Cola()

    {

        inicio = null;

        fin = null;

    }

   

    // Encolar (agregar al final)

    public void Encolar(int valor)

    {

        Nodo nuevo = new Nodo(valor);

       

        if (EstaVacia())

        {

            inicio = nuevo;

            fin = nuevo;

        }

        else

        {

            fin.siguiente = nuevo;

            fin = nuevo;

        }

    }

   

    // Desencolar (eliminar del inicio)

    public int Desencolar()

    {

        if (EstaVacia())

        {

            throw new InvalidOperationException("La cola está vacía");

        }

       

        int valor = inicio.dato;

        Nodo temp = inicio;

       

        if (inicio == fin)

        {

            inicio = null;

            fin = null;

        }

        else

        {

            inicio = inicio.siguiente;

        }

       

        temp.siguiente = null;

        return valor;

    }

   

    // Verificar si la cola está vacía

    public bool EstaVacia()

    {

        return inicio == null;

    }

   

    // Mostrar todos los elementos de la cola

    public void Mostrar()

    {

        if (EstaVacia())

        {

            Console.WriteLine("La cola está vacía");

            return;

        }

       

        Nodo actual = inicio;

        Console.Write("Cola: ");

        while (actual != null)

        {

            Console.Write(actual.dato + " ");

            actual = actual.siguiente;

        }

        Console.WriteLine();

    }

}

 

// Programa principal para probar la cola

class Program

{

    static void Main(string[] args)

    {

        Cola miCola = new Cola();

       

        Console.WriteLine("=== DEMO COLA CON NODOS EN C# ===\n");

       

        // Encolar elementos

        miCola.Encolar(10);

        miCola.Encolar(20);

        miCola.Encolar(30);

        miCola.Mostrar();  // Salida: Cola: 10 20 30

       

        // Desencolar

        Console.WriteLine($"Desencolado: {miCola.Desencolar()}");  // 10

        miCola.Mostrar();  // Salida: Cola: 20 30

       

        // Más operaciones

        miCola.Encolar(40);

        miCola.Encolar(50);

        miCola.Mostrar();  // Salida: Cola: 20 30 40 50

       

        Console.WriteLine($"¿Está vacía? {miCola.EstaVacia()}");

    }

}