giumi

copilot

copilot

C
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main() {
    int N, i, sueldo, count_above_3000 = 0;
    int min_sueldo = 4500; // inicializar al valor máximo posible
    double percentage_above_3000;

    // Semilla para la generación de números aleatorios
    srand(time(NULL));

    // Solicitar al usuario un valor para N
    do {
        printf("Ingrese un valor para N (debe ser mayor a 10): ");
        scanf("%d", &N);
    } while (N <= 10);

    int sueldos[N];

    // Generar sueldos aleatorios y calcular los requerimientos
    for (i = 0; i < N; i++) {
        sueldo = (rand() % (4500 - 1200 + 1)) + 1200;
        sueldos[i] = sueldo;
        printf("Sueldo del trabajador %d: %d soles\n", i + 1, sueldo);

        if (sueldo > 3000) {
            count_above_3000++;
        }

        if (sueldo < min_sueldo) {
            min_sueldo = sueldo;
        }
    }

    // Calcular el porcentaje de trabajadores con sueldo mayor a 3000
    percentage_above_3000 = ((double)count_above_3000 / N) * 100;

    // Mostrar resultados
    printf("Porcentaje de trabajadores con sueldo mayor a 3000 soles: %.2f%%\n", percentage_above_3000);
    printf("El menor sueldo es: %d soles\n", min_sueldo);

    return 0;
}

1. Compila el programa utilizando un compilador de C, como gcc. Por ejemplo:

   gcc nombre_del_archivo.c -o ejecutable
   

2. Ejecuta el archivo resultante:

   ./ejecutable
   

giumi

copilot

Markdown
```mermaid
flowchart TD
    A[Inicio] --> B[Solicitar valor para N]
    B --> C{¿N > 10?}
    C -->|No| B
    C -->|Sí| D[Inicializar sueldos]
    D --> E[Para i de 1 a N]
    E --> F[Generar sueldo aleatorio entre 1200 y 4500]
    F --> G[Mostrar sueldo]
    G --> H{¿Sueldo > 3000?}
    H -->|Sí| I[Incrementar contador de sueldos > 3000]
    H -->|No| J
    I --> J{¿Es el menor sueldo?}
    J -->|Sí| K[Actualizar menor sueldo]
    J -->|No| L
    K --> L[Incrementar i]
    L -->|i <= N| E
    L -->|i > N| M[Calcular porcentaje de sueldos > 3000]
    M --> N[Mostrar porcentaje]
    N --> O[Mostrar menor sueldo]
    O --> P[Fin]

### Explicación del diagrama:

- **Inicio**: Comienza el programa.
- **Solicitar valor para N**: Se pide al usuario que ingrese un valor para $N$.
- **Validar que $N > 10$**: Se verifica si el valor de $N$ es mayor a 10. Si no lo es, se solicita nuevamente.
- **Inicializar sueldos**: Se prepara para generar sueldos aleatorios.
- **Iteración i**: Se inicia un bucle para calcular sueldos para cada trabajador desde 1 hasta $N$.
- **Generar sueldo aleatorio**: Se crea un sueldo aleatorio para cada trabajador.
- **Mostrar sueldo**: Se imprime el sueldo generado.
- **Verificar sueldo mayor a 3000**: Si el sueldo es mayor a 3000, se incrementa un contador.
- **Actualizar menor sueldo**: Se verifica si el sueldo actual es menor que el mínimo encontrado y se actualiza si es así.
- **Calcular y mostrar resultados**: Una vez terminada la generación de sueldos, calcula el porcentaje de sueldos mayores de 3000 y muestra el sueldo mínimo.
- **Fin**: Termina el programa después de mostrar los resultados.

Este diagrama de flujo visualiza la lógica del programa y puede ser utilizado para comprender el flujo de control y la lógica usadas para implementar el cálculo de sueldos.

giumi

copilot

1. Inicio: Se inicia el programa.
2. Declaración: Declarar las variables int a, b, c;.
3. Entrada: Pedir al usuario que ingrese el valor de b usando scanf.
4. Inicialización: Asignar a = 4; y c = 4;.
5. Ciclo do-while:

   • Condición: Mientras $a \leq b$.

6. Condición if:

   • Si $a < 12$, entonces $c = c - a$.
   • Si no, $c = c + a$.

7. Incremento: Aumentar $a$ en 2 ($a += 2$).
8. Repetir Ciclo: Regresar al paso 5 si la condición del ciclo do-while se cumple.
9. Salida: Imprimir el valor final de $c$ con printf.
10. Fin: Termina el programa con return 0;.

Plaintext
[Inicio]
  |
  v
[Declarar Variables: a, b, c]
  |
  v
[Leer b]
  |
  v
[a = 4, c = 4]
  |
  v
[Inicio Ciclo Do-While]
  |
  v
 ¿a <= b?
Yes --> [ a < 12? ] -> Yes --> [ c = c - a] --> [a = a + 2]
  |          |
 No         No
  |          v
  v      [ c = c + a ] --> [a = a + 2]
  |          |
  v          v
[Fin Do-While]
  |
  v
[Imprimir c]
  |
  v
[Fin]

giumi

copilot

Plaintext
$$Inicio$$
  |
  v
$$Declarar\ Variables:\ int\ a,\ b,\ c$$
  |
  v
$$Solicitar\ y\ Leer\ el\ valor\ de\ b$$
  |
  v
$$a\ =\ 4$$
$$c\ =\ 4$$
  |
  v
$$Inicio\ del\ ciclo\ Do-While$$
  |
  v
 $$¿a\ <=\ b?$$
  |    \
 No    Sí
  |     \
  v      v
$$Imprimir\ c$$   $$¿a\ <\ 12?$$
                |    \
               No    Sí
                |     \
                v      v
        $$c\ =\ c\ +\ a$$ $$c\ =\ c\ -\ a$$
                |     |
                v     v
             $$a\ =\ a\ +\ 2$$
                |
                v
$$Regresar\ al\ inicio\ del\ ciclo$$
  |
  v
$$Fin$$

• Inicio: El programa comienza ejecutando la función principal.
• Declaración e Iniciación:

  • Se declaran las variables a, b, y c.
  • Se lee el valor de b con scanf.
  • Las variables a y c se inicializan a 4.

• Ciclo Do-While:

  • Mientras a sea menor o igual a b, se repite el ciclo.
  • Dentro del ciclo, se evalúa si a es menor que 12.
  • Si $a < 12$, se realiza $c = c - a$.
  • De lo contrario, $c = c + a$.
  • Independiente del bloque del if, a se incrementa en 2.

• Condición de Salida: Se comprueba la condición $a <= b$ para continuar el ciclo.
• Resultado y Fin: Una vez finaliza el ciclo, se imprime el valor de c y el programa termina.

giumi

copilot

Python
from graphviz import Digraph

# Create a new directed graph
dot = Digraph()

# Add nodes with shapes corresponding to flowchart convention
dot.node('Start', 'Comienza', shape='ellipse')
dot.node('Declare', 'Declarar Variables:\nint a, b, c;', shape='parallelogram')
dot.node('Input', 'Ingrese y Leer b', shape='parallelogram')
dot.node('Init', 'a = 4;\nc = 4;', shape='rectangle')
dot.node('DoWhile', 'Inicio del Ciclo Do-While', shape='ellipse')
dot.node('Condition', '¿a <= b?', shape='diamond')
dot.node('If', '¿a < 12?', shape='diamond')
dot.node('Subtract', 'c = c - a;', shape='rectangle')
dot.node('Add', 'c = c + a;', shape='rectangle')
dot.node('Increment', 'a = a + 2;', shape='rectangle')
dot.node('EndLoop', 'Fin del Ciclo', shape='ellipse')
dot.node('Print', 'Imprimir c\nValor de c:', shape='parallelogram')
dot.node('End', 'Fin', shape='ellipse')

# Add edges with instructions for decisions
dot.edge('Start', 'Declare')
dot.edge('Declare', 'Input')
dot.edge('Input', 'Init')
dot.edge('Init', 'DoWhile')
dot.edge('DoWhile', 'Condition')
dot.edge('Condition', 'If', label='Sí')
dot.edge('Condition', 'Print', label='No')
dot.edge('If', 'Subtract', label='Sí')
dot.edge('If', 'Add', label='No')
dot.edge('Subtract', 'Increment')
dot.edge('Add', 'Increment')
dot.edge('Increment', 'EndLoop')
dot.edge('EndLoop', 'Condition')
dot.edge('Print', 'End')

# Render the flowchart to a file
dot.format = 'png'
file_path = '/mnt/data/flowchart'
dot.render(file_path)

file_path + '.png'

Image

---

giumi

copilot

giumi