Mensajes

Esta es mi solución:

Código (c) [Seleccionar] Expandir


#include <stdlib.h>
#include <stdio.h>
#include <string.h>

void printchars(int __char, int ntimes) {
    for(int i = 0; i < ntimes; ++i)
        putchar(__char);
}

int main()
{
    int N;
    int nspaces;
    int nasterisks;
    scanf("%d", &N);
   
    nspaces = N * 2 - 1;
   
    nasterisks = 1;
    for(int i = 0; i < N; ++i) {
        printchars(' ', nspaces);
        printchars('*', nasterisks);
        --nspaces;
        nasterisks += 2;
        putchar('\n');
    }
   
    nasterisks = 1;
    for(int i = 0; i < N; ++i) {
        printchars(' ', nspaces);
        printchars('*', nasterisks);
        printchars(' ', (N - i) * 2 - 1);
        printchars('*', nasterisks);
        --nspaces;
        nasterisks += 2;
        putchar('\n');
    }
   
    return 0;
}

Animaos a publicar vuestros códigos. El ejercicio es interesante.

Pregunta en el foro de ingeniería inversa.
Te diran como buscar y modificar cadenas dentro de los binarios.

Crea una variable en la clase para ir guardando el resultado de las operaciones. Esa variable se puede reiniciar a 0 con un botón.
Haz un método que actualice esa variable según el valor que se le pase.
A cada método de los botones:
Llame al método que te he dicho con el valor que le toca y despues despliegue el resultado de la variable por el textbox, que para más profesionalidad, puede ser de solo lectura.

Os propongo un ejecicio:
Realizar la figura que se muestra a continuación en el ejemplo.
El programa debe aceptar un entero que representa la altura de los triangulos pequeños que forman el total.
Así, con la entrada de un 5 se consigue:

Código [Seleccionar] Expandir


         *
        ***
       *****
      *******
     *********
    *         *
   ***       ***
  *****     *****
*******   *******
********* *********

Con una entrada de un 3:

Código [Seleccionar] Expandir


     *
    ***
   *****
  *     *
***   ***
***** *****


cadena es un objeto que devuelve la dirección de inicio del array al que representa, es recir, tanto si se lo das a printf con %p, que imprime direcciones de memoria, te tiene que dar lo mismo ya que cadena y &cadena son equivalentes:  los dos devuelven la dirección del primer elemento del array.

Un puntero es una variable más y sigue las mismas reglas que todas las variables.

La pila tiene registros dedicados en la CPU e instrucciones en su repertorio para su manejo, lo que la hace rápida en su acceso. Pero debido a su naturaleza, está pensada para el manejo de las funciones, la pila se va moviendo arriba y abajo. Allí se guardan las variables locales de las funciones, llamadas automáticas. Cuándo una función termina y regresa el registro que marca el final de la pila regresa al punto en que estaba antes de llamar a dicha función, todo lo que había de ésta desaparece. Como puedes ver no se pueden guardar datos que trasciendan a la vida de las funciones, como las constantes.
Por otra parte grandes estructuras, arrays y clases, si se guardan en la pila, para moverlos entre funciones se gasta una gran cantidad de tiempo ya que hay que copiar su contenido una y otra vez, para eso se guardan en el montón (heap), así solo se copia un puntero, que al fin y al cabo es del tamaño igual a la palabra del procesador y por ende el objeto que más rápido se copia.

La palabra clave inline hace lo mismo, lo que en ese caso la definición de la función puede hacerse en el archivo .cpp

[arrays]

Tienes razón.
Donde dice: Una cosa curiosa es que si dos arrays distintos los inicializas en el código
Debe decir: Una cosa curiosa es que si dos punteros distintos los inicializas en el código

Las operaciones entre enteros da resultado entero. Convierte uno de los operandos en real, mediante un cast,  multiplicándole 1.0 o cambiando su tipo de int a float y la división te devolverá un real.