void trocar(int m[][T])
{
int k, l, n;
int aux;
/* Processamento e Saída*/
/* linhas 2 <-> 8 */
for (k = 0; k < T; k++) {
for (l = 0; l < T; l++) {
if (k == 1) {
aux = m[1][l];
m[1][l] = m[7][l];
m[7][l] = aux;
}
}
}
printf("\nTroca das linhas 2 e 8\n");
imprimirMatriz(m);
/* colunas 4 <-> 10 */
for (k = 0; k < T; k++) {
for (l = 0; l < T; l++) {
if (l == 3) {
aux = m[k][3];
m[k][3] = m[k][9];
m[k][9] = aux;
}
}
}
printf("\nTroca das colunas 4 e 10\n");
imprimirMatriz(m);
/* diagonais */
for (k = 0; k < T; k++) {
for (l = 0; l < T; l++) {
if (k + l == T-1) {
aux = m[k][l];
m[k][l] = m[k][k];
m[k][k] = aux;
}
}
}
printf("\nTroca das diagonais\n");
imprimirMatriz(m);
/* linha 5 <-> coluna 10 */
l = 0;
for (k = 0; k < T-1; k++) {
if (l == 4) {
l++;
}
aux = m[4][k];
m[4][k] = m[l][9];
m[l][9] = aux;
l++;
}
printf("\nTroca da linha 5 e coluna 10\n");
imprimirMatriz(m);
}
int main() {
int g[V][V];
inicializar(g);
imprimirMatriz(g);
adicionarAresta(3,3,g);
adicionarAresta(1,2,g);
adicionarAresta(3,4,g);
imprimirMatriz(g);
excluirAresta(1,2,g);
imprimirMatriz(g);
}
main()
{
int A[DIM][DIM], B[DIM][DIM];
lerMatriz(A);
lerMatriz(B);
printf("\nMatriz A: \n");
imprimirMatriz(A);
printf("\nMatriz B: \n");
imprimirMatriz(B);
printf("\nSoma: \n");
somarMatrizes(A, B);
printf("\nSubtracao: \n");
subtrairMatrizes(A, B);
}
int main(void){
//declaracion de variables
bool seAcabo=false;
int casos=1;
int m;
int n;
char matrizEtrada[M][N];
int matrizSalida[M][N];
//lectura de la entrada
while(!seAcabo){
scanf("%i %i",&m,&n);
if(m==0 && n==0){
seAcabo=true;
}
int i=0;
int j=0;
for(i;i<m;i++){
j=0;
for(j;j<n;j++){
scanf("%c",matrizEtrada[i][j]);
}
}
if(!seAcabo){
calcularMatrizDeBombasAdyacentes(matrizSalida,matrizEtrada,m,n);
printf("FIELD #%i:\n",casos);
imprimirMatriz(matrizSalida,m,n);
casos++;
}
}
return 0;
}
void realizarJogada(char m[TAM][TAM], char jogador, int *vez){
int x,y;
system("clear");
printf("####### Jogador %c #######\n",jogador);
printf("Informe o valor de X: ");
scanf("%i", &x);
printf("Informe o valor de Y: ");
scanf("%i", &y);
// Verifica se o local nos valores X e Y
// esta disponivel para jogada.
if(m[x][y] == 'L'){
m[x][y] = jogador;
*vez = *vez + 1;
}else if(m[x][y] == 'B'){
system("clear");
printf("Jogador %c Perdeu!!\n",jogador);
imprimirMatriz(m);
system("pause");
*vez = 1;
inicializarMatriz(m);
gerarBombas(m);
}else{
system("clear");
printf("Nao eh possivel realizar a jogada!\n");
system("pause");
}
}
int main(int argc, char *argv[]){
int A[4][4];
int B[4][4];
int aux = 1;
struct tipoDeDatos C = {2,3.87};
for (int i = 0; i < 4; ++i){
for (int j = 0; j < 4; ++j){
B[i][j] = aux++;
}
}
invertirMatriz(&A[0][0],&B[0][0]);
printf("Matriz invertida: \n");
imprimirMatriz(A);
printf("\nMatriz multiplicada: \n");
multiplicarMatriz(A,C,fopen((argc > 1 ? argv[1]:"resultado.txt"),"w"));
/*
if (argc > 1){
multiplicarMatriz(A,C,fopen(argv[1],"w"));
}else{
multiplicarMatriz(A,C,fopen("resultado.txt","w"));
}*/
return 0;
}
int main() {
int nFilas,nColumnas;
char nombreFichero[100];
float *matriz=NULL;
int retval;
printf("Introduzca el número de filas de la matriz a leer: ");
scanf(" %d",&nFilas);
printf("Introduzca el número de columnas de la matriz a leer: ");
scanf(" %d",&nColumnas);
printf("Introduzca el nombre del fichero: ");
scanf(" %s",nombreFichero);
matriz=(float *) malloc(nFilas*nColumnas*sizeof(float));
if (matriz==NULL) {
printf("No se pudo reservar memoria para la matriz\n");
system("PAUSE");
return 3;
}
if (retval=leerMatriz(nombreFichero,nFilas,nColumnas,matriz)) {
printf("Hubo un error al leer el fichero\n");
system("PAUSE");
return retval;
}
imprimirMatriz(nFilas,nColumnas,matriz);
system("PAUSE") ;
return 0 ;
}
int main(){
seed();
int matriz_A[x][y];
int matriz_B[x][y];
int suma[x][y];
llenarMatriz(matriz_A);
imprimirMatriz(matriz_A);
llenarMatriz(matriz_B);
imprimirMatriz(matriz_B);
sumarMatrices(matriz_A, matriz_B, suma);
imprimirMatriz(suma);
}
void PageRankEsparso::imprimirEsparso(const vector< map<int, double> > &A) {
vector< vector<double> > v(A.size(), vector<double>(A.size(), 0));
for (unsigned int i = 0; i < A.size(); i++) {
typedef map<int, double>::const_iterator it_type;
for(it_type iterator = A[i].begin(); iterator != A[i].end(); iterator++) {
v[i][iterator->first] = iterator->second;
}
}
imprimirMatriz(v);
}
int main(){
int m1[LIN][COL], m2[LIN][COL];
int soma[LIN][COL];
printf("Cadastrar valores para M1\n");
cadastrarMatriz(m1);
printf("Cadastrar valores para M2\n");
cadastrarMatriz(m2);
printf("\t\tImprimir valores de M1\n");
imprimirMatriz(m1);
printf("\t\tImprimir valores de M2\n");
imprimirMatriz(m2);
printf("\t\tImprimir Soma das Matrizes\n");
realizarSomaMatrizes(m1,m2,soma);
imprimirMatriz(soma);
}
int main (void) {
int n,
matriz[LINHAS][COLUNAS];
while(scanf("%d\n", &n) != EOF) {
montarMatriz(matriz, n);
imprimirMatriz(matriz, n);
}
return 0;
}
void main() {
int matriz[1][1], inversa[1][1], adjunta[1][1], determinante;
unsigned int dimensao, linha, coluna;
for(linha = 0; linha < dimensao; linha++) {
for(coluna = 0; coluna < 2; coluna++) {
printf("Informe o elemento matriz[%d][%d]: ", linha+1, coluna+1);
scanf("%u", &matriz[linha][coluna]);
printf("\n");
}
}
/*calcula o determinante da matriz*/
determinante = matriz[0][0]*matriz[0][1] - matriz[1][0]*matriz[1][1];
/*montar matriz adjunta*/
adjunta[0][0] = matriz[1][1];
adjunta[0][1] = -matriz[1][0];
adjunta[0][1] = -matriz[1][0];
printf("Matriz original\n");
imprimirMatriz(matriz, dimensao);
printf("\n");
printf("Matriz transposta\n");
imprimirMatriz(transposta, dimensao);
printf("\n");
if(simetrica)
printf("As matrizes são simétricas\n");
else
printf("As matrizes não são simétricas\n");
if(antisimetrica)
printf("As matrizes são anti-simétrica\n");
else
printf("As matrizes não são anti-simétrica\n");
}
int main(){
int f, c, mat[MAXF][MAXC];
for(f = 0; f < MAXF; f++){
for(c = 0; c < MAXC; c++){
printf("Ingrese un número entero: ");
scanf("%d", &mat[f][c]);
}
}
imprimirMatriz(mat);
return 0;
}
void subtrairMatrizes(int a[][DIM], int b[][DIM])
{
int i, j, res[DIM][DIM];
for (i = 0; i < DIM; i++) {
for (j = 0; j < DIM; j++) {
res[i][j] = a[i][j] - b[i][j];
}
}
imprimirMatriz(res);
}
int main(void)
{
int iRen = 5;
int iCol = 6;
float** fMat = crearMatriz(iRen,iCol);
llenarMatriz(fMat,iRen,iCol);
imprimirMatriz(fMat,iRen,iCol);
destruirMatriz(fMat,iRen);
return 0;
}
int main(){
VetorBi *m= matriz(9,9);
int i,j;
atribuirValores(m);
printf("Sudoku\n\n");
imprimirMatriz(m);
desalocar(m);
system("pause");
return 0;
}
main()
{
/* vars */
float M[T][T];
float media;
printf("MEDIA DOS ELEMENTOS SOB AS DUAS DIAGONAIS\n\n");
/* Entrada */
lerMatriz(M);
/* Processamento e Saída */
printf("\nM:\n");
imprimirMatriz(M);
media = calcularMediaSobDiagonalPrincipalESecundaria(M);
printf("\nMEDIA = %.2f\n", media);
}
main()
{
/* vars */
int k, l, soma;
int A[7][T];
printf("SOMA DOS ELEMENTOS DA LINHA 5 E COLUNA 3\n\n");
/* Entrada */
lerMatriz(A, 7);
/* Processamento*/
soma = somar(A, 7);
/* Saída */
printf("\nA:\n");
imprimirMatriz(A, 7);
printf("\nSOMA = %i\n", soma);
}
main()
{
/* vars */
int A[T][T];
int i, j;
printf("TROCA DE LINHAS, COLUNAS E DIAGONAIS DE UMA MATRIZ\n\n");
/* Entraada */
printf("\nCarregando matriz %ix%i:\n", T, T);
for (i = 0; i < T; i++) {
for (j = 0; j < T; j++) {
printf("m[%i][%i]: ", i, j);
scanf("%i", &A[i][j]);
}
}
/* Processamento e Saída */
printf("\nA:\n");
imprimirMatriz(A);
trocar(A);
}
int main()
{
int v[5], i, j, k, x=0, troca, m[5][5];
freopen("e6.txt", "r", stdin);
freopen("s6.txt", "w", stdout);
for (i=0 ; i<L ; i++)
{
ler(v);
ordenar(v);
popularMatriz(m, v, x);
x++;
}
imprimirMatriz(m);
fclose(stdin);
fclose(stdout);
return 0;
}
void main(int argc, char* const argv[])
{
if(argv[1]== NULL) {
perror("Digite el tamaño de la matriz N");
exit(-1);
}
if(argv[2] == NULL) {
perror("Digite el numero de hilos ");
exit(-1);
}
int N = atoi(argv[1]);
int nHilos = atoi(argv[2]);
printf("N = %i, numero hilos= %i\n", N, nHilos);
if (N != 2 && N != 4 && N != 8 && N != 16 && N != 32 && N != 64 && N != 128 && N != 256 && N != 512 && N!= 1024)
{
perror("El tamaño debe ser un numero de estos [2,4,8,16,32,64,128, 256, 512, 1024]");
exit(-1);
}
if(nHilos > N) {
perror("Los hilos deven ser menores o iguales a el tamaño");
exit(-1);
}
int i=0;
int *MATRIZA[N];
for (i=0; i<N; i++)
MATRIZA[i] = (int *)malloc(N * sizeof(int));
initMatriz(N,N,MATRIZA);
//imprimirMatriz(N,N,MATRIZA);
int *MATRIZB[N];
for (i=0; i<N; i++)
MATRIZB[i] = (int *)malloc(N * sizeof(int));
initMatriz(N,N,MATRIZB);
//imprimirMatriz(N,N,MATRIZB);
int *MATRIZC[N];
for (i=0; i<N; i++)
MATRIZC[i] = (int *)malloc(N * sizeof(int));
int particiones = N/nHilos;
#pragma omp parallel num_threads(nHilos)
{
int ID = omp_get_thread_num();
int inicioParte = ID*(particiones);
int finParte = (ID+1)*(particiones);
int k=0;
//printf("inicioParte->%i, finParte->%i\n", inicioParte,finParte);
int i = 0;
for (i = inicioParte; i < finParte; i++)
{
int j = 0;
for (j = 0; j < N; j++)
{
filaXcolum(N,i,j,MATRIZA,MATRIZB,MATRIZC);
//printf("DATO:%i\n",dato );
//printf("res %i %i el [%i]\n",i,j,hiloInfo->C[i][j]);
k++;
}
}
}
imprimirMatriz(N,N,MATRIZA);
imprimirMatriz(N,N,MATRIZB);
imprimirMatriz(N,N,MATRIZC);
}
int main(int argc,char *argv[]){
if (argc!=4){
printf("Has introducido %i parametros.\n",argc);
printf("Sintaxis: <nombre programa> <archivo de matriz 1> <archivo de matriz 2> <archivo de salida>\n");
exit(1);
}
FILE *fEntrada1, *fEntrada2, *fSalida;
int** mEntrada1;
int** mEntrada2 = NULL;
//Dimensiones de las matrices
int filasA, columnasA, filasB, columnasB;
fEntrada1=fopen(argv[1],"r");
fEntrada2=fopen(argv[2],"r");
fSalida=fopen(argv[3],"w");
if(!fEntrada1 || !fEntrada2 || !fSalida){
printf("Error abriendo ficheros. Compruebe que el fichero de entrada existe\r\n");
exit(1);
}
//Lee los valores de las dos matrices y cerrar los ficheros correspondientes
leerMatriz(&mEntrada1, &filasA, &columnasA, fEntrada1);
leerMatriz(&mEntrada2, &filasB, &columnasB, fEntrada2);
fclose(fEntrada1);
fclose(fEntrada2);
if((filasA!=columnasB)||(columnasA!=filasB)){
printf("\n\n*********Matrices incompatibles************\r\n");
printf("Filas de A: %d; Columnas de A: %d;\r\nFilas de B: %d; Columnas de B: %d;\r\n ", filasA, columnasA, filasB, columnasB);
fclose(fSalida);
exit(1);
}
int i, j, k, sum=0;
int* offset;
int** resultado = malloc(filasA*(sizeof(int*)+columnasB*sizeof(int)));
offset = (int*) resultado + filasA;
for(i=0; i<filasA; i++, offset+=columnasB)
resultado[i]=offset;
for(i = 0; i < filasA; i++)
for(j = 0; j < columnasB; j++){
sum = 0;
for(k=0; k < filasB; k++)
sum += mEntrada1[i][k]*mEntrada2[k][j];
resultado[i][j] = sum;
}
printf("Matriz 1: \r\n");
imprimirMatriz(mEntrada1, filasA, columnasA);
printf("Matriz 2: \r\n");
imprimirMatriz(mEntrada2, filasB, columnasB);
printf("Resultado: \r\n");
imprimirMatriz(resultado, filasA, columnasB);
escribirMatriz(resultado, filasA, columnasB, fSalida);
fclose(fSalida);
free(mEntrada1);
free(mEntrada2);
free(resultado);
return 0;
}
