Tienes LOWER() y UPPER(). Minúsculas y mayúsculas.

La diferencia entre una a mayúscula de una A minúscula es la misma que la diferencia entre una a y una b. Son letras diferentes, sin más. No tienen por qué tener relación.

En el caso de ASCII, sí que tienen relación (1 bit diferencia mayúsculas de minúsculas).

Si quieres diferenciar también por 1 bit, pues tendrás que añadir 1 bit a los códigos. Y bueno, si ese bit está a 1, dices que son mayúsculas, y si está a 0, minúsculas (o al revés, como quieras.)

Podrías construir una matriz bidimensional M\N e irla rellenando. Y cuando calcules un valor más grande, la haces más grande.

Sin embargo, esta función da resultados muy grandes muy temprano cuando aumenta M, así que...

Una posibilidad sería utilizar estas formulas: https://es.wikipedia.org/wiki/Funci%C3%B3n_de_Ackermann#Tabla_de_valores
Cuando M esté en el rango [0,3], puedes retornar directamente las fórmulas que aparecen (n+1, n+2, 2n+3, 8*(2^n) - 3).

Si realmente lo quieres hacer con memroia dinámica, almacenando valores intuyo, entonces es solo tener una matriz. Si al llamar a la función, la matriz tiene esa posicion ya calculada, la retornas sin más. Sino, la calculas recursivamente tal como lo tienes, la guardas, y la retornas.
En caso de que se pidan valores de M o N fuera dle rango de la matriz, habrá que incrementar su tamaño generando otra matriz y copiando los valores antiguos.
Para posiciones de la matriz que aun no han sido calculadas, puedes guardar un 0, por ejemplo, que es un valor que no existe en esta función que yo sepa.

Correcto.

(edad >= 18) && ( ¿_? < 21)

Como en matemáticas.

Lo de "hola".

No no, osea, o con array [N] o con malloc. Me refiero a que comenté lo del array porque solo os vi haciéndolo con malloc, como otra posibilidad.
Sí que se podría hacer con char vector[2][50].

No es ese tipo de foros Pero lo anoto en mi libreta de puntos imaginarios

Oh sí. La única peculiaridad es la de la constante. A parte de eso, eres libre.


Como en los códigos de arriba lo hicisteis todo con malloc, pues por si acaso xD

¿Leerlo completo e imprimirlo completo? No entiendo. scanf va a leer la entrada del usuario completa y printf va a imprimir la variable completa (hasta el '\0', claro).

No se debe modificar una cadena literal ("abc"). El comportamiento de esto no está definido. Hay compiladores que colocan la cadena en una zona de memoria de solo-lectura, por ejemplo.

Para leer nuevos datos, tendrás que reservar nueva memoria.

Por cierto, depende de las necesidades pero, también se puede hacer esto con un array:

#include <stdio.h>
 
int main(){
    char str[50];
 
    scanf("%s", str);
 
    printf("%s", str);
}

Si compilas con GCC, puedes pasar el argumento "-S" para que genere el ensamblador en vez de el binario. Además, pasarle -O0 para que no optimice el código (y así tener el código tal como tú lo generaste).

Por ejemplo, este es el ASM desglosado del programa que probé (suerte que lo recuperé de la papelera de reciclaje) (está en C++, pero ninguna parte importante):

#include <iostream>
 
using namespace std;
 
int main(){
	int n = 1;
 
	cout << n++ + ++n * n++;
}
 
/*
 
 
movl    $1, n ; int n = 1
 
movl    n, %edx
leal    1(%edx), %eax
movl    %eax, n ; n++ (first, edx = old value)
 
addl    $1, n ; ++n
 
movl    n, %eax
leal    1(%eax), %ecx
movl    %ecx, n ; n++ (second, eax = old value)
 
imull   n, %eax
 
addl    %edx, %eax
 
 
*/

No sé si controlas ensamblador, y no es parte del tema, pero como breve resumen:
movl mueve el valor del primer operando al segundo.
leal es más complejo. pero aquí, en resumen, cuando pone 1(operando), lo que hace es sumarle 1 al operando y guardarlo en el segundo operando
imull multiplica y almacena el resultado en el segundo operando
addl suma y almacena elr esultado en el segundo operando

Separé cada "operador" por un salto de línea. (Inicialmente no ponía "n", ponía -12(%esp), que es donde se almacenan las variables locales. Pero lo cambié a n por legibilidad.

Y bueno, el ensamblador no miente. Primero, mueve un 1 a n.
Luego, hace el primer post-incremento, y almacena el valor antiguo (que es el que se suma realmente), en edx (registro, que serían como las variables de ASM).
Siguiente, hace el pre-incremento. Sin ir más lejos, añade 1. Trivial.
Luego, segundo post-incremento. Incrementa n, y almacena el valor antiguo en eax.

Y ahora las otras operaciones. Empezamos ya con el problema que había. Hace imull n, %eax. eax es el valor del post-incremento, todo correcto, pero, como vimos, n lo ha incrementado ya las 3 veces, así que va a multiplicar por ese valor.

Y finalmente, la suma, trivial también.

God bless you, y recuerda que si tú juegas con el lenguaje, el lenguaje jugará contigo :X

Este tema es un poco complicado ya la verdad. En primer lugar, el comportamiento en estos casos es indefinido. http://es.cppreference.com/w/cpp/language/eval_order#Comportamiento_indefinido

Aun siendo así, la explicación de que de 13 es esta:

Antes de nada, tengamos en cuenta un par de cosas: el post-incremento retorna un nuevo valor, nada extraño. Sin embargo, el pre-incremento retorna una referencia (lvalue) de la variable. Esto significa que ++n no se transforma en "5", por ejemplo. ++n se transforma en n. Con esto en cuenta, resolvámoslo:

int n = 1;
 
n++ + ++n * n++;
 
1 + ++n * n++;
// n = 2
 
1 + n * n++; // Nótese que aquí cambiamos ++n por n, no por su valor, porque es una referencia, y el valor siempre estará vinculado a la variable
// n = 3
 
1 + n * 3;
// n = 4
 
1 + 4 * 3; // Llegados a este punto, sacamos el valor de esa n
 
1 + 12
 
13

Ese ++n puede generar un poco de confusión (a mi me la acaba de enerar, tuve que mirar el ensamblador que genera el compilador xD)

En fin, si bien esto es puramente "académico" y "curioso", pues eso, mejor evitar usar _++ y ++_ en donde puedan generar confusión (como poniendo varios en la misma sentencia).

El _++ incrementa en el mismo momento. La diferencia con respecto al ++_ es que el post-incremento retorna el valor antiguo, y el pre-incremento retorna el nuevo valor.

int n = 0;
int j = n++;
// Cuando se ejecuta el n++, quedaría como:
int j = 0;

Sin embargo:

int n = 0;
int j = ++n;
// Cuando se ejecuta el ++n, quedaría como:
int j = 1;

Con estio quiero decir: ++_ y _++ son exactamente lo mismo, excepto en 2 aspectos: orden de ejecución y valor retornado.

Para comprobar que el _++ efectivamente incrementa el valor, puedes probar así:

#include <stdio.h>
 
int main(){
	int n = 1;
	printf("%i %i", n++, n);
}