Mensajes

[y se ve algo pequeño]

Pensé que eran multiplataforma.
El DevC++ lo uso de block de notas. Tengo la tele de monitor y se ve algo pequeño, y en el DevC++ se ve mucho mejor.

Supongo que te refieres a que en Coce::Bloks se ven las letras pequeñas, pero puedes cambiar el tamaño de las mismas aplicando un zoom pulsando la tecla control y la ruedita del ratón, y pones la resolución que mejor se adapte a tu vista.

Saludito! ... ..

[dat000]

Muy bien dat000, sólo una pequeña precisión. El la declaración de:

Código (cpp) [Seleccionar] Expandir

string nombre[100];

el 100 no tiene mucho sentido ya que sólo se van a  guardar 5 alumnos, en este supuesto, con lo que yo propongo:

Código (cpp) [Seleccionar] Expandir

string nombre[5];

Y por otro lado puedo llegar a entender el uso de while como una imposición, pero no como una opción lógica. Para bucles en que se conozcan los valores a introducir es más razonable y simple el uso de los for, dejando el uso de while y do-while para aquellos casos en que no se tiene el total de iteraciones sino que se impone alguna condición para la salida del bucle. Incluso en algunos de estos  casos podría servir el for, que como comenté me parece más fácil/transparente de construir y seguir. Y en este sentido propongo una alternativa con for:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#define FILA    5
#define COLUMNA 3
using namespace std;

int main(void)

{
    string nombre[FILA];
    int cal[FILA][COLUMNA]; //Son 3 calificaciones para 5 alumnos, se usa una matriz bidimensional 5 filas X 3 columnas
    int fila=0; // contador para alumnos, puede ser n, el nombre del contador sirve de referencia
    int columna=0; // contador para las calificaciones
    for (fila=0;fila < FILA;fila ++)
    {
        cout << "Dame el nombre " << (fila+1) << ":  ";
        cin >> nombre[fila];
        for (columna=0;columna < COLUMNA;columna++)
        {
            cout<<"Dame la calificacion "<<(columna+1)<<" de "<<nombre[fila]<<":  ";
            cin>>cal[fila][columna];
            columna++;
        }
    }
    cout << endl << "******CALIFICACIONES******" << endl << endl;
    for (fila=0;fila < FILA;fila ++)
    {
        cout<<nombre[fila] << ":  ";
        for (columna=0;columna < COLUMNA;columna++)
        {
            cout<<cal[fila][columna]<< " ";
            columna++;
        }
        cout << endl;
    }
    cout << endl;
    return 0;
}


Aunque me repito, si se trata de practicar con while ta´O.K.

Saluditos!. ... ..

[yo trabajo en borland c++ y ahí arrancan sin necesidad del using namespace std;]

mmm de hecho yo trabajo en borland c++ y ahí arrancan sin necesidad del using namespace std; pero igual muchísimas gracias si has resuelto mi problema 

Sorry, sorry, sorry cien veces. De todas formas creo que deberías intentar programar ajustándote al C/C++ estándar, más que nada para que tus programas sean "portables". y de nuevo, sorry por la ignorancia de ese detalle del compilador de borland.

Saluditos!. .... ...

[porque dijiste]

..............................................................
Te dijo lo de error porque dijiste que para multiplicarlas deben ser cuadradas obligatoriamente. Y eso es falso.

Round Two. ¡Fight!

NEW ROUND.

Yo no dije eso, sacas mis palabras del  contexto. Yo lo que dije es que al introducir las mismas dimensiones para las dos matrices sólo queda la opción de que sean cuadradas para poder multiplicarlas. Esto que digo no es que para multiplicar matrices sen obligatoriamente cuadradas .....¿ta´claro ahora?.

!Hasta el próximo round, si quieres ........

[a pelo, sin arrays]

hacer lo se hacer asi pero como en el libro no han presentado array, solo por eso lo quise hacer asi .

Pues muy bien por tí   a pelo, sin arrays. Esta visto que con pocos conocimientos de C/C++, y lo digo también por mí, se pueden hacer cosas interesantes.

Pero entre nosotros, como cuestión practica está bien, pero como método de cifrado no sirve de nada. Al usar un método constante en el cifrado, con la potencia de cálculo de los ordenadores actuales, y en este caso incluso a mano,  se lograría obtener el método seguido en el cifrado con relativa facilidad.

Enhorabuena en todo caso por lo logrado y muchos ánimos para seguir profundizando en este mundillo.

Saluditos!. ... ..

[a mi si me compila bien]

mmmm gracias por tu sugerencia pero a mi si me compila bien, es decir la libreria iostream si esta escrita bien  .__.? igual muchisimas gracias por el codigo :O muchas gracias era lo que buscaba...

Dudo lo mucho, sin "using namespace std;" difícil que "arranquen"  los cin y cout y respecto a la librería, una cosa es lo que hay y otra lo que había.

En cualquier caso el asunto era resolverte una duda, cosa que parece he conseguido.

Saluditos!. ... ..

[La condición que ha puesto es correcta]

¡Error!

Para multiplicar dos matrices, la segunda tiene que tener el mismo número de columnas que la primera. La condición que ha puesto es correcta pero debe retornar un NULL para indicar que no se pudo hacer.

Creo que no te has fijado bien o más bien no basta con el "pantallazo" para salir de dudas.

Si te fijas comienza introduciendo las dimensiones de una matriz y sus elementos, para posteriormente preguntar si quiere introducir otra matriz, pero ya no pregunta por las dimensiones. Fíjate en el "sub-pantallazo":



¿Ves como en esta segunda matriz entra los dato directamente?. No ha preguntado por la dimensión de esta nueva matriz y claro, en estas condiciones ambas , al no ser cuadradas, no cumplen con la condición de que la segunda tenga el mismo número de columnas que la primera.  

Pero todo es un suponer a partir de la dichosa imagen, pues a lo mejor, pudiera ser  que, es posible que ..... haya introducido previamente las dichositas dimensiones.

Vamos, querido colega amchacon, que para no perder la costumbre quería llevarte un poquito la contraria ...... ....porfi, tómalo como un cumplido.

Un fuerte abrazo y como siempre .......Saluditos!. .... ...

[una]

Tal como "aparenta" el código, sólo introduces las dimensiones de una matriz lo que da como resultado que siempre podrás sumarlas y restarlas pero como multiplicarlas tienen que ser cuadradas, sino no se cumple la condición para poder multiplicarlas.

Tendrás que modificar el código para que puedas introducir las dimensiones de cada matriz de forma independiente.

Saluditos!. ... ...

REEDITO:Te arroja valores basura porque te vas fuera de las dimensiones y serán debidos a otra parte del código.

[creo]

Casi sin querer me he visto envuelto en una vorágine de color, todo por querer mejorar la presentación tan "sosa" de la consolita del C/C++.

Por lo pronto creo que he conseguido la gama de colores 8 bits, conformando así una paleta de 256 colores por combinación de la tabla de colores "básicos" para el fondo y los caracteres dada por la aplicación de la siguiente tabla/regla:

PARA LA CONSOLA: system ("color numero(fondo)letra(letras)")

Otra forma es coger una combinación de fondo y letra:

n=16*fondo+letra

Color fondo de consola :

0 = Negro
1 = Azul
2 = Verde
3 = Aguamarina
4 = Rojo
5 = Purpura
6 = Amarillo
7 = Blanco
8 = Gris
9 = Azul claro

Color de texto:

A=10 = Verde claro
B=11 = Aguamarina claro
C=12 = Rojo claro
D=13 = Purpura claro
E=14 = Amarillo claro
F=15 = Blanco brillante

y aplicar el resultado "n" a:
       
   SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );

Si nos fijamos bien hay 255 (16x16-1, porque empieza contando desde cero) combinaciones que se corresponden a lo indicado al principio.

Y éste es el resultado de esas combinaciones:



No salen los 256 porque no cabían en la pantalla.   Y el código con el cual he generado la tabla anterior:

Código (cpp) [Seleccionar] Expandir

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

int color (int n);

int main()
{
   int n=0,matriz[10][30]={0}, i, j;
   for(i=0;i<9;i++)
{
       for(j=0;j<30 && n<256 ;j++,n++)
       {
          if (j%10==0  )
               printf ("\n");
           matriz[i][j]=n;
           color (n);
           printf("  %d  ", matriz[i][j]);
           color (7);
           printf("\t");
       }
}
   system("pause");
   return 0;
}

int color (int n)
{
       SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
}


Pero, siempre tiene que haber un pero, queda lejos del sistema RGB (Red Green Blue)que usa una paleta de 256 por color que da como resultado: 256 x 256 x 256 = 16.777.216 colores distintos,  o sea 24 bits Vamos, la opción casi por defecto de colores en los monitores actuales.

Este valor se representa en hexadecimal, con lo que el rango va de 00 a FF por cada uno de ellos. El código se expresa así: #RRGGBB siendo cada uno de los valores de 2 cifras el rango de cada uno de los 3 colores, con lo que obtenemos el valor final que representa a cada color....

Dicho esto, podemos ver algunos ejemplos:

- Negro: representa la ausencia de color, por tanto su valor será: #000000
- Blanco: es la mezcla de todos los colores: #FFFFFF
- Rojo: todo el tono es del rojo, siendo los otros 2 nulos: #FF0000
- Verde: sólo aparece el verde, sin tener valor los otros 2: #00FF00
- Azul: idéntico razonamiento, pero sólo con el azul: #0000FF

Esto da como resultado un estándar, el UNIX11 dándose la  coincidencia de color de los nombres usados en Windows Presentation Foundation (WPF) ,la versión 1,0 de Microsoft .NET Framework , nombres de formularios Windows Forms, y de Microsoft Internet Explorer color.

Muestro  en la siguiente tabla los principales nombres de colores X11:



Y aquí surge mi duda/pregunta, ¿alguien puede orientarme, en el sentido de cómo acceder a toda esa gama de colores desde "código"?. Sí, ya sé que hay que buscar en las API pero es todo un mundo que estoy lejos de manejar con cierta soltura, de ahí mi petición de orientación "pero" a algo concretito, nada de páginas que yo mismo puedo encontrar googleando.

Espero les haya gustado mi modesta paleta de colores de 8 bits, quedo a la espera de poder usar la de 24 bits.

Saluditos! .... ...


P.D:Gracias a mr.blood por la defensa que hizo en otro foro de "mi/su" código del tema de matrices de 10x10, ya que el "cara" del usuario hxcbps, que no había aportado nada digno de mención, colgo el código como suyo con la esperanza de que otros le "terminaran" la tarea

Y conste que no es que me importe compartir y ayudar dentro de mis modestísimas posibilidades/conocimientos del C/C++, que no, pero una cosa es ayudar y otra colgarse medallitas ajenas. Un mínimo de cortesía/honestidad. Y si expreso esto es porque cuando entró en este foro ya venía "rebotado" de otro foro, más concretamente del Rincón del C. Nuevamente, gracias  mr.blood.

[Ya que no es necesario el uso de la función pow]

Ya que no es necesario el uso de la función pow para pasar de binario a decimal la limitante es el numero de bits del acumulador, si se utiliza una variable de tipo int se tienen como mínimo 16, 32 en el caso del tipo long.

Tal como indique, sólo recordaba por encima el número de dígitos capaz de manejar C/C++, que comenté estaban entre 15 y 20. Preciso, entre 10 de los enteros y enteros largos y 19 de los long long en mi ordenador, claro:



Que creo que  cuasi se corresponden con los 16 y 32 bits que comentabas y las correspondientes potencias de 2, toda vez que mi int y long int es de cuatro bytes, o sea 32 bits y mi long long int es de 8 bytes, es decir 64 bits.



Por cierto,calculadas  con pow y con iguales resultados que sin pow por lo que deduzco que la función implementada en C es análoga a la acumulativa expuesta por tí.



Conclusión, saquemos alguna conclusión de esta diatriba: C/C++ se queda "cortito" de manera estándar en el manejo de dígitos, muy lejos de la cantidad de dígitos que muestra la figura de mi post anterior con las potencias de 2, por cierto no calculadas con ninguna librería auxiliar o programa matemático sino con Python, aunque reconozco que no me he molestado en comprobar la bondad de dichos resultados ya que para esas cosas manejo otros programas más específicos.

Saluditos!. ... ..

P.D:Sniff,Sniff    me da nostalgia al contemplar la" potencia" de programas como Matlab o Mathematica, que sin despeinarse dan, y lo pongo cortito para que no ocupe mucho:

Código (cpp) [Seleccionar] Expandir


2^10000=
1995063116880758384883742162683585083823496831886192454852008949852943
8830221946631919961684036194597899331129423209124271556491349413781117
5937859320963239578557300467937945267652465512660598955205500869181933
1154250860846061810468550907486608962488809048989483800925394163325785
0621568309473902556912388065225096643874441046759871626985453222868538
1616943157756296407628368807607322285350916414761839563814589694638994
1084096053626782106462142733339403652556564953060314268023496940033593
4316651459297773279665775606172582031407994198179607378245683762280037
3028854872519008344645814546505579296014148339216157345881392570953797
6911927780082695773567444412306201875783632550272832378927071037380286
6393031428133241401624195671690574061419654342324638801248856147305207
4319922596117962501309928602417083408076059323201612684922884962558413
1284406153673895148711425631511108974551420331382020293164095759646475
6010405845841566072044962867016515061920631004186422275908670900574606
4178569519114560550682512504060075198422618980592371180544447880729063
9524254833922198270740447316237676084661303377870603980341319713349365
4622700563169937455508241780972810983291314403571877524768509857276937
9264332215993998768866608083688378380276432827751722736575727447841122
9438973381086160742325329197481312019760417828196569747589816453125843
4135959862784130128185406283476649088690521047580882615823961985770122
4070443305830758690393196046034049731565832086721059133009037528234155
3974539439771525745529051021231094732161075347482574077527398634829849
8340756937955646638621874569499279016572103701364433135817214311791398
2229838458473344402709641828510050729277483645505786345011008529878123
8947392869954083434615880704395911898581514577917714361969872813145948
3783202081474982171858011389071228250905826817436220577475921417653715
6877256149045829049924610286300815355833081301019876758562343435389554
0917562340084488752616264356864883351946372037729324009445624692325435
0400678027273837755376406726898636241037491410966718557050759098100246
7898801782719259533812824219540283027594084489550146766683896979968862
4163631337639390337345580140763674187771105538422573949911018646821969
6581651485130494222369947714763069155468217682876200362777257723781365
3316111968112807926694818872012986436607685516398605346022978715575179
4738524636944692308789426594821700805112032236549628816903573912136833
8393591756418733850510970271613915439590991598154654417336311656936031
1222499379699992267817323580231118626445752991357581750081998392362846
1524988108896023224436217377161808635701546848405862232979285387562348
6556440536962622018963571028812361567512543338303270029097668650568557
1575055167275188991941297113376901499161813151715440077286505731895574
5092033018530484711381831540732405331903846208403642176370391155063978
9000742853672196280903477974533320468368795868580237952218629120080742
8195513179481576244482985184615097048880272747215746881315947504097321
1508049819045580341682694978714131606321068639151168177430479259670937
6