Mensajes

El modo de resolución a mí sí me parece que es iterativo. Si no es lo que buscas añade un poco más de código para ver qué es lo que quieres implementar.

Te dejo este tema que es de hace muy poco tiempo y creo que se trató este mismo tema. Quizás pueda servirte.
https://foro.elhacker.net/programacion_cc/problema_kpaired_kemparejados_en_on-t499246.0.html

Supongo que es en C y no en C++, no?
Bueno, te respondo para C.
Ese código tuyo lo que hace es asignar el valor que tienes guardado en la variable <un_numero> a cada posición de la matriz por lo que son todo 0.
Para que los valores los introduzca el usuario tienes que pedírselos.

Código (c) [Seleccionar] Expandir


#define MAX_SIZE 10

void tablero(int matriz[][MAX_SIZE]){ // la primera dimension no es necesario ponerla. Si se pone tampoco pasa nada
    for(int i = 0; i < MAX_SIZE; ++i){
        for(int j = 0; j < MAX_SIZE; ++j){
            printf("Introduce el valor de matriz[%d][%d]: ", i, j); // muestras por pantalla este mensaje para que el usuario introduzca un valor
            scanf("%d", &matriz[i][j]); // guardas el valor que introduce el usuario en la posicion correspondiente
        }
    }
}

[Los códigos ponlos entre etiquetas de Código GeSHi... y a ser posible bien tabulados]

Los códigos ponlos entre etiquetas de Código GeSHi... y a ser posible bien tabulados

De lo que tienes: las funciones <suma()> y <leer_complejo()> están bien implementadas y la función <escribir_complejo()> tiene un error a la hora de mostrar los valores.

Código (c) [Seleccionar] Expandir


void escribirComplejo(Complejo numero){
    printf("La parte real es: %f y la parte compleja es: %f", numero.x, numero.y);
}
Se pone primero una cadena entre comillas con el texto que se quiera mostrar y el formato de las variables que se van a mostrar y finalizada la cadena entre comillas, se ponen las variables que se sustituirán en los %f de la cadena.
Al ser una función que no devuelve nada, es innecesario poner el <return> al final.

Veo que todavía te faltan algunas de las cosas que te piden así que te pongo por aquí cosillas aisladas que tendrás que ver cómo las usas para lo que te están pidiendo.

• Crear número aleatorios: para crear un número entero aleatorio en el intervalo [minimo, maximo]:
  
  Código (c) [Seleccionar] Expandir
  
#include <stdlib.h>
#include <ctime> // se usa para la funcion time

int main(){
    srand(time(NULL)); // semilla para generar numeros aleatorios. Si no se pone esta linea los numeros seran siempre los mismos
    int numeroAleatorio = minimo + rand() % (maximo - minimo + 1);
}
  
  
• Rellenar un array con números:
  
  Código (c) [Seleccionar] Expandir
  
#define SIZE 10 // definimos la longitud maxima del array

int main(){
    int numeros[SIZE];
    for(size_t i = 0; i < SIZE; ++i) // en vez de size_t se puede usar int tambien
        numeros[i] = i; // se guardara {0,1,2,3,4,5,6,7,8,9}
}
  
  
• Obtener sumas de manera recursiva. Te pongo un ejemplo que continuaría con el código anterior. Sería sumar de manera recursiva los 10 valores que hemos guardado.
  
  Código (c) [Seleccionar] Expandir
  
int sumarRecursiva(int numeros[], int size, int currentIndex){
    if(currentIndex == size-1)
        return numeros[currentIndex];
    return numeros[currentIndex] + sumarRecursiva(numeros, SIZE, currentIndex + 1);
}
  
  Como creo que te estoy dando bastante hecho aunque tengas que adaptarlo a tu problema, te dejo la parte de mostrar el array de manera recursiva para que lo intentes tú antes de decirte también cómo se hace.

Tienes dos números de 3 dígitos y lo que te piden es multiplicar el primer dígito de cada número con el tercero y ver si coinciden.
Supón los números n1 y n2 y cada uno formado por 3 dígitos tal que:

Código [Seleccionar] Expandir


n1 = a b c // tal que n1 = a * 100 + b * 10 + c
n2 = d e f  // tal que n2 = d * 100 + e * 10 + f
Lo "complicado" de este ejercicio es obtener el primer y tercer dígito. Para ello hay que usar dos operadores: el de división entera (/) y el de módulo (%). El primero calcula el cociente de dividir un número entre otro y el segundo calcula el resto de dividir un número entre otro.
Para obtener los dígitos <a> y <c> de <n1> podemos hacer:

Código [Seleccionar] Expandir


n1 = 123; // un ejemplo
n1digito1 = n1 / 100; // el resultado de esto seria 1
n1digito3 = n1 % 10; // el resultado de esto seria 3
Tendrías que hacer lo mismo para <n2> y multiplicar los dígitos que obtienes y comprobar si son iguales o no.

Si tienes algún problema más puedes poner tu código entre etiquetas de Código GeSHi para que podamos verlo y así ayudarte mejor.

No sé si te he entendido bien. Lo que yo entiendo es que tienes dos vectores por ejemplo:

Código [Seleccionar] Expandir


v1 = {0,2,4,6,8}
v2 = {1,3,5,7,9}
Y por ejemplo te piden buscar el correspondiente en v2 al 4 en v1. El 4 en v1 está en la posición 2 (te recuerdo que los vectores empiezan a contar en la posición 0) entonces el correspondiente sería el elemento 2 de v2, que sería el 5.
Para ello tendrás una variable para el elemento que estás buscando (el 4 en este ejemplo) y un contador que determine su posición. Entonces vas recorriendo el primer vector y vas comparando cada elemento con el que buscas y vas incrementando el contador hasta encontrarlo. Una vez encontrado, recoges el valor de v2 que está en la posición que indica el contador.

Código [Seleccionar] Expandir


v1 : array de enteros
v2 : array de enteros
INICIO
    PEDIR elementoBuscado // 4 en este caso
    resultado := -1 // aqui estara el resultado si lo encontramos. Si no lo encontramos se quedara con el -1
    i := 0
    MIENTRAS elementoBuscado != v1[i] && i < v1.longitud HACER // la i se va incrementando hasta que v1[i] coincida con 4 o hasta que se acabe v1
        i := i + 1
    FIN MIENTRAS
    // aqui llegamos cuando encontramos el elemento que buscamos, 4 en este caso, o cuando llegamos al final de v1
    SI elementoBuscado == v1[i] HACER // si esto se cumple sera que hemos encontrado el elemento. Si no se cumple es que el elemento buscado no existe y entonces el resultado sera un -1 o el valor que tu elijas para saber que el elemento no se ha encontrado
        resultado = v2[i] // i es el contador que nos dice la posicion del elemento. En este caso i valdria 2 y entonces resultado valdria 5
    FIN SI
FIN
Esto que te he puesto sería un algoritmo (los pasos) para resolver el ejercicio. No está en C por lo que si lo copias tal cual no te va a funcionar. Tienes que leer el algoritmo e intentar entenderlo. Cuando ya lo tengas tienes que hacerlo en C a tu manera.
Si tienes problemas para entenderlo o para escribirlo en lenguaje C puedes exponer los problemas o dudas que tengas y si tienes algo de código hecho puedes ponerlo entre etiquetas de Código GeSHi para que se vea así:

Código (c) [Seleccionar] Expandir


#include <stdio.h>

int main(){

}

No sé si a lo que te estás intentando referir es al paso de parámetros por referencia... Es decir, pasar dos parámetros a un método y que el propio método modifique los valores y esos valores se queden modificados una vez haya terminado el método.
En Java hasta donde yo sé no existe el paso por referencia (no como en C/C++ que sí existe) para tipos de datos primitivos, sin embargo, si creas una clase y lo que pasas es un objeto, el objeto está referenciado y eso te permitiría modificar sus atributos. (ACLARO: el objeto está referenciado, no se pasa por referencia, se sigue pasando por valor pero se pasa por valor su referencia).

Si por ejemplo en tu caso tienes una clase <dimensionespantalla> que contiene dos atributos (o más): <largo> y <ancho>; y quieres guardar estos atributos en otras variables lo que te recomendaría sería usar dos métodos <getter>: <getLargo()> y <getAncho()> y que cada uno te devuelva un atributo de la instancia.

PD: Los códigos ponlos entre etiquetas de Código GeSHi y selecciona como lenguaje: Java para facilitar la lectura a los demás y evitar problemas de formato...

Todo depende de tus intereses. No sé si buscas un lenguaje con el que situarte en el mundo laboral o quieres seguir con la programación por afición, pero una vez que conoces la lógica de la programación (que ya la habrás aprendido con Java) es casi igual siempre. Por ejemplo con Java tienes muchas puertas abiertas y si quieres lenguajes similares tienes por ejemplo C++. Si lo que prefieres son lenguajes de más alto nivel tienes por ejemplo Python o también puedes ir hacia javascript u otros.
Como ya te digo, todo depende de para qué lo quieras.

Echarte una mano sí podemos. Hacerte la tarea no...
Y la verdad es que esta parte la veo un poco rebuscada y creo que la condición está mal ya que es la misma:

Código [Seleccionar] Expandir


sino
    si n<100 entonces
        digitos :=((n div 10) + (n mod 10 )) mod 3 =0 ;
    sino
___________________________________

___________________________________

La función <main()> puede recibir dos parámetros: un <int> y un <char*[]>. El primero indica el número de parámetros que le pasas al programa cuando lo ejecutas desde línea de comandos y el segundo es como una matriz donde cada fila es uno de los parámetros y cada columna es una letra. El nombre que le des da igual, siempre es lo mismo.

Como te han dicho, una pila internamente se puede implementar con un <array>. Entonces lo que tienes que hacer es un <array> de números en donde guardar los números hasta encontrar un operador. Yo estoy hablando para una notación polaca inversa, es decir, 3 4 +.
Te dejo el siguiente pseudocódigo. Esto es para que lo entiendas. Cuando entiendas cómo funciona tienes que pasarlo a C ya que el pseudocódigo no está escrito en C.

Código [Seleccionar] Expandir


INICIO
    posicionActual := 0
    PEDIR expresion
    PARA i := 0 HASTA expresion.longitud - 1 HACER
        SEGUN expresion[i] HACER
            numero:
                numeros[posicionActual++] = expresion[i]
            +:
                numeros[posicionActual - 2] := numeros[posicionActual - 2] + numeros[posicionActual - 1]
                posicionActual := posicionActual - 2
            *:
                numeros[posicionActual - 2] := numeros[posicionActual - 2] + numeros[posicionActual - 1]
                posicionActual := posicionActual - 2

            //...igual para el resto de operadores

        FIN SEGUN
    FIN PARA

    MOSTRAR numeros[0]
FIN