{"id":764,"date":"2018-11-12T11:23:12","date_gmt":"2018-11-12T13:23:12","guid":{"rendered":"http:\/\/www.galirows.com.br\/meublog\/programacao\/?p=764"},"modified":"2021-06-18T14:56:15","modified_gmt":"2021-06-18T17:56:15","slug":"algoritmo-solicitado2","status":"publish","type":"post","link":"http:\/\/www.galirows.com.br\/meublog\/programacao\/algoritmo-solicitado2\/","title":{"rendered":"Algoritmo solicitado 2"},"content":{"rendered":"\n

A solicita\u00e7\u00e3o de algoritmo foi enviada por Hedson Ferreira. A solicita\u00e7\u00e3o foi enviada por coment\u00e1rio no blog e n\u00e3o foi enviada corretamente conforme solicito (veja a forma correta aqui<\/a>), mas resolvi atender mesmo assim. O enunciado \u00e9 o seguinte:<\/p>\n\n\n\n

Fa\u00e7a um algoritmo em linguagem C com as seguintes funcionalidades:<\/p>\n\n\n\n

  1. Receba duas matrizes como dados e entrada. A dimens\u00e3o das matrizes deve ser de, no m\u00e1ximo 5×5. Ambas matrizes devem ter as mesmas dimens\u00f5es;<\/li>
  2. O usu\u00e1rio deve digitar a dimens\u00e3o das matrizes (m\u00e1ximo 5×5). Fa\u00e7a uma checagem usando um la\u00e7o de repeti\u00e7\u00e3o que s\u00f3 permita o programa avan\u00e7ar caso ele digite dimens\u00f5es corretas de no m\u00e1ximo 5;<\/li>
  3. Escreva ambas matrizes na tela, de uma forma leg\u00edvel;<\/li>
  4. Escreva a matriz resultante da soma destas duas matrizes multiplicada pelos \u00faltimos dois n\u00fameros da sua matricula;<\/li>
  5. Escreva um vetor resultante da soma das diagonais principais das duas matrizes multiplicado pelos \u00faltimos dois n\u00fameros da sua matricula;<\/li><\/ol>\n\n\n\n
    #include<stdio.h>\n#include<stdlib.h>\n#include<math.h>\n\n#define LINHAS 3\n#define COLUNAS 3\n\nint mat1  [LINHAS][COLUNAS] = {0};\nint mat2  [LINHAS][COLUNAS] = {0};\nint soma [LINHAS][COLUNAS] = {0};\nint mulp [LINHAS][COLUNAS] = {0};\nint i, j, ru;\n\nint main() {\n    printf(\" Digite os 2 ultimos numero R.U.: \"); \/*identifica\u00e7\u00e3o do fator de multiplica\u00e7\u00e3o*\/\n    scanf(\"%d\", &ru);\n   \n\t\n    for(int i = 0; i<LINHAS; i++) {\n        for(int j = 0; j<COLUNAS; j++) {\n            printf(\"Digite o valor %d|%d =  \", i, j);\n            scanf(\"%d\", &mat1[i][j]);\n        }\n    }\n    printf(\"\\n     1.a Matriz gerada\\n\");\n    for(int i=0;i<LINHAS;i++) {\n        for(int j=0;j<COLUNAS;j++) {\n            printf(\"%d\\t\", mat1[i][j]); \n        }\n        printf(\"\\n\");\n    }\n \n    for(int i = 0; i<LINHAS; i++)\t{\n        for(int j = 0; j<COLUNAS; j++)\t{\n            printf(\"Digite o valor %d|%d =  \", i, j);\n            scanf(\"%d\", &mat2[i][j]);\n        }\n    }\n    printf(\"\\n     2a. Matriz gerada\\n\");\n    for(int i=0;i<LINHAS;i++) {\n    for(int j=0;j<COLUNAS;j++) {\n       printf(\"%d\\t\", mat2[i][j]); \n    }\n    printf(\"\\n\");\n  }\n  \/\/ c\u00e1lculo da soma dos valores\n  for(i=0;i<LINHAS;i++)\n      for(j=0;j<COLUNAS;j++)\n          m[i][j]=m[i][j]*ru;\n  \/\/EXIBIR VALORES MULTIPICADOS\n  printf(\"\\n::: Valores Multiplicados pelo fator ru:::\\n\");\n \n \n  system(\"pause\");\n   return 0;\n}<\/code><\/pre>\n\n\n\n
    O c\u00f3digo tentou atender os 4 primeiros itens, ent\u00e3o vou auxiliar na solu\u00e7\u00e3o desses 4 itens. Inicialmente, vou alterar o algoritmo para atender a primeira parte da quest\u00e3o, que consiste em ter matrizes com uma dimens\u00e3o informada pelo usu\u00e1rio at\u00e9 o limite m\u00e1ximo de 5 linhas e 5 colunas.<\/p>\n\n\n\n
    Por ter um limite m\u00e1ximo definido e ele n\u00e3o ser muito grande, a solu\u00e7\u00e3o feita pelo\u00a0Hedson, onde duas constantes foram definidas (linhas 5 e 6) para definir o tamanho das matrizes (linhas 8-11), pode ser empregada. Vale a ressalva de que existir\u00e1 uma subutiliza\u00e7\u00e3o da matriz para valores menos do que os das constantes e que seria melhor fazer uma aloca\u00e7\u00e3o din\u00e2mica dos recursos, mas como disse, o tamanho das matrizes n\u00e3o est\u00e1 muito grande.<\/p>\n\n\n\n
    Eu adicionei as linhas 15-20 ao c\u00f3digo para atender aos itens 1 e 2 do enunciado. O usu\u00e1rio informa as dimens\u00f5es e eu verifico se os valores digitados atendem as limites do problema. Eu verifiquei se os valores digitados eram maiores do que zero e tamb\u00e9m menores do que 5. Se os valores para as duas dimens\u00f5es n\u00e3o forem v\u00e1lidos, ent\u00e3o novos valores s\u00e3o solicitados.<\/p>\n\n\n\n
    Com a indica\u00e7\u00e3o da dimens\u00e3o das matrizes vinda do usu\u00e1rio, foi preciso alterar as condi\u00e7\u00f5es de teste dos la\u00e7os de repeti\u00e7\u00e3o for para que os la\u00e7os fossem percorridos at\u00e9 o limite informado pelo usu\u00e1rio e n\u00e3o mais pelas constantes. Sendo assim, nas especifica\u00e7\u00f5es troquei as constantes “LINHAS” e “COLUNAS” pelas vari\u00e1veis “lin” e “col”, respectivamente, lidas do usu\u00e1rio.<\/p>\n\n\n\n
    O restante do c\u00f3digo mantive conforme estava, apenas alterando a ordem com que s\u00e3o feitas as opera\u00e7\u00f5es. O Hedson faz leitura da primeira matriz, mostra os valores da primeira matriz, depois faz a leitura da segunda matriz e depois mostra a segunda matriz. Eu prefiro ler os valores das duas matrizes e depois mostrar os valores das duas matrizes, mas \u00e9 prefer\u00eancia pessoal minha. Acho que fica mais f\u00e1cil localizar as opera\u00e7\u00f5es no c\u00f3digo.<\/p>\n\n\n\n
    #include<stdio.h>\n#include<stdlib.h>\n#include<math.h>\n\n#define LINHAS 5\n#define COLUNAS 5\n\nint mat1  [LINHAS][COLUNAS] = {0};\nint mat2  [LINHAS][COLUNAS] = {0};\nint soma [LINHAS][COLUNAS] = {0};\nint mulp [LINHAS][COLUNAS] = {0};\nint i, j, ru, lin, col;\n\nint main() {\n    \/\/faz a leitura da dimensao das matrizes\n    printf(\"Digite a dimensao das matrizes: \"); \/*identifica\u00e7\u00e3o do fator de multiplica\u00e7\u00e3o*\/\n\tscanf(\"%d %d\", &lin, &col);\n\twhile ((lin > 5 || col > 5) && (lin < 0 || col < 0)) {\n\t\tprintf(\"Dimensoes incorretas. Digite a dimensao das matrizes: \");\n\t\tscanf(\"%d %d\", &lin, &col);\n\t}\n\t\n    \/\/faz a leitura dos valores da primeira matriz\n    for(int i = 0; i<lin; i++) {\n        for(int j = 0; j<col; j++) {\n            printf(\"Digite o valor %d|%d =  \", i, j);\n            scanf(\"%d\", &mat1[i][j]);\n        }\n    }\n    \n    \/\/faz a leitura dos valores da segunda matriz\n    for(int i = 0; i<lin; i++) {\n        for(int j = 0; j<col; j++) {\n            printf(\"Digite o valor %d|%d =  \", i, j);\n            scanf(\"%d\", &mat2[i][j]);\n        }\n    }\n    \n    \/\/Mostra os valores das duas matrizes\n    printf(\"\\n     1.a Matriz gerada\\n\");\n    for(int i=0;i<lin;i++) {\n        for(int j=0;j<col;j++) {\n            printf(\"%d\\t\", mat1[i][j]); \n        }\n        printf(\"\\n\");\n    }\n\n    printf(\"\\n     2a. Matriz gerada\\n\");\n    for(int i=0;i<lin;i++) {\n        for(int j=0;j<col;j++) {\n            printf(\"%d\\t\", mat2[i][j]); \n        }\n        printf(\"\\n\");\n    }\n\n    system(\"pause\");\n    return 0;\n}<\/code><\/pre>\n\n\n\n
    A pr\u00f3xima etapa consiste em ler o n\u00famero de matr\u00edcula e utilizar os dois \u00faltimos dois d\u00edgitos para multiplicar esse valores com soma dos valores das matrizes.<\/p>\n\n\n\n
    Extrair os dois \u00faltimos d\u00edgitos de um n\u00famero \u00e9 f\u00e1cil se o n\u00famero de d\u00edgitos do n\u00famero for fixo, mas eu vou considerar que a quantidade de d\u00edgitos pode variar. Nesse sentido fica dif\u00edcil elaborar um c\u00e1lculo para extrair a dezena e a unidade do n\u00famero, ent\u00e3o vou fazer a leitura da matr\u00edcula como uma string, pegar os dois \u00faltimos caracteres e transform\u00e1-los para n\u00famero. Essas opera\u00e7\u00f5es s\u00e3o feitas nas linhas x-y do trecho de c\u00f3digo abaixo.<\/p>\n\n\n\n
    Existem formas mais f\u00e1ceis, mas eu quis utilizar a fun\u00e7\u00e3o b\u00e1sica de concatena\u00e7\u00e3o. Eu inicialmente leio o n\u00famero da matr\u00edcula como uma string e pego o tamanho da string atrav\u00e9s da fun\u00e7\u00e3o strlen(), da biblioteca string.h. A ideia \u00e9 depois pegar os dois \u00faltimos caracteres e utilizar a fun\u00e7\u00e3o atoi(), que converte string para n\u00famero inteiro.<\/p>\n\n\n\n
    matricula[tamMatricula-1] pega corretamente o \u00faltimo d\u00edgito e matricula[tamMatricula-2] pega corretamente o pen\u00faltimo d\u00edgito. S\u00f3 para relembrar, se a matr\u00edcula tem 8 d\u00edgitos, ent\u00e3o strlen() retornar\u00e1 o tamanho 8, mas a string \u00e9 um vetor de caracteres e come\u00e7a com o \u00edndice zero. Com isso a \u00faltima letra estar\u00e1 na posi\u00e7\u00e3o 7, enquanto a pen\u00faltima estar\u00e1 na posi\u00e7\u00e3o 6.<\/p>\n\n\n\n
    Inicialmente eu tentei erroneamente fazer simplemente ru = atoi(strcat(matricula[tamMatricula-1], matricula[tamMatricula-2]));<\/em>. Isso n\u00e3o funciona porque a fun\u00e7\u00e3o strcat() concatena as strings e guarda o resultado da concatena\u00e7\u00e3o no primeiro par\u00e2metro. Como eu passei matricula[tamMatricula-1] como primeiro par\u00e2metro, n\u00e3o \u00e9 v\u00e1lido que nessa posi\u00e7\u00e3o (que armazena uma \u00fanica letra) eu guarde toda uma string.<\/p>\n\n\n\n
    Sendo assim eu criei a string ult<\/em> com 3 caracteres. Defini 3 caracteres porque a string dever\u00e1 ao final guardar os dois \u00faltimos d\u00edgitos da matricula e tamb\u00e9m, por ser uma string, o caracter de final de string, o ‘\\0’. As linhas 9 e 10 atribuem o \u00faltimo d\u00edgito a vari\u00e1vel de string que criei. Veja que \u00e9 necess\u00e1rio colocar o caracter finalizador de linha e que esse deve ser fornecido utilizando aspas simples. Por mais que utilizemos dois caracteres para escrever o finalizador de linha, ele \u00e9 apenas 1 caracter.<\/p>\n\n\n\n
    Tentei em seguida fazer strcat(ult, matricula[tamMatricula-2]);<\/em>, mas mais um erro ocorreu. O segundo par\u00e2metro da strcat() tamb\u00e9m precisa ser uma string e da maneira que fiz informei apenas um caracter, o que n\u00e3o \u00e9 v\u00e1lido. Por isso tive que atribuir o pen\u00faltimo caracter em uma outra string para s\u00f3 depois fazer a devida concatena\u00e7\u00e3o e finalmente passar a string para a fun\u00e7\u00e3o atoi().<\/p>\n\n\n\n
        char matricula[10], ult[3], pen[2]; \n    int tamMatricula;   \n    printf(\"Digite a matricula: \"); \/*identifica\u00e7\u00e3o do fator de multiplica\u00e7\u00e3o*\/\n    scanf(\"%s\", matricula);\n    tamMatricula = strlen(matricula); \/\/pega o tamanho da string\n\n    \/\/ru = atoi(strcat(matricula[tamMatricula-1], matricula[tamMatricula-2]));\n    \n    ult[0] = matricula[tamMatricula-1];\n    ult[1] = '\\0';\n\n    \/\/strcat(ult, matricula[tamMatricula-2]);\n\n    pen[0] = matricula[tamMatricula-2];\n    pen[1] = '\\0';\n    strcat(ult, pen);\n    ru = atoi(ult);<\/code><\/pre>\n\n\n\n
    O restante \u00e9 simples. Eu apenas percorri as matrizes somando seus valores e j\u00e1 multiplicando pelos dois \u00faltimos d\u00edgitos da matr\u00edcula. Ao final foi mostrada a matriz com os valores resultantes. O c\u00f3digo completo \u00e9 mostrado a seguir:<\/p>\n\n\n\n
    #include<stdio.h>\n#include<stdlib.h>\n#include<math.h>\n#include<string.h>\n\n#define LINHAS 5\n#define COLUNAS 5\n\nint mat1  [LINHAS][COLUNAS] = {0};\nint mat2  [LINHAS][COLUNAS] = {0};\nint soma [LINHAS][COLUNAS] = {0};\nint mulp [LINHAS][COLUNAS] = {0};\nint i, j, ru, lin, col;\n\nint main() {\n\t\/\/faz a leitura da dimensao das matrizes\n    printf(\"Digite a dimensao das matrizes: \"); \/*identifica\u00e7\u00e3o do fator de multiplica\u00e7\u00e3o*\/\n\tscanf(\"%d %d\", &lin, &col);\n\twhile ((lin > 5 || col > 5) && (lin < 0 || col < 0)) {\n\t\tprintf(\"Dimensoes incorretas. Digite a dimensao das matrizes: \");\n\t\tscanf(\"%d %d\", &lin, &col);\n\t}\n\t\n\t\/\/faz a leitura dos valores da primeira matriz\n    for(int i = 0; i<lin; i++) {\n        for(int j = 0; j<col; j++) {\n            printf(\"Digite o valor %d|%d =  \", i, j);\n            scanf(\"%d\", &mat1[i][j]);\n        }\n    }\n    \n    \/\/faz a leitura dos valores da segunda matriz\n    for(int i = 0; i<lin; i++) {\n        for(int j = 0; j<col; j++) {\n            printf(\"Digite o valor %d|%d =  \", i, j);\n            scanf(\"%d\", &mat2[i][j]);\n        }\n    }\n    \n    \/\/Mostra os valores das duas matrizes\n    printf(\"\\n     1.a Matriz gerada\\n\");\n    for(int i=0;i<lin;i++) {\n        for(int j=0;j<col;j++) {\n            printf(\"%d\\t\", mat1[i][j]); \n        }\n        printf(\"\\n\");\n    }\n\n    printf(\"\\n     2a. Matriz gerada\\n\");\n    for(int i=0;i<lin;i++) {\n        for(int j=0;j<col;j++) {\n            printf(\"%d\\t\", mat2[i][j]); \n        }\n        printf(\"\\n\");\n    }\n   \n    \/\/pega o dois ultimos digitos das matriculas\n    char matricula[10], ult[3], pen[2]; \n    int tamMatricula;   \n    printf(\"Digite a matricula: \"); \/*identifica\u00e7\u00e3o do fator de multiplica\u00e7\u00e3o*\/\n    scanf(\"%s\", matricula);\n    tamMatricula = strlen(matricula);\n    ult[0] = matricula[tamMatricula-1];\n    ult[1] = '\\0';\n    pen[0] = matricula[tamMatricula-2];\n    pen[1] = '\\0';\n    ru = atoi(strcat(ult, pen));\n    printf(\"%d\", ru);\n    \n    \/\/ c\u00e1lculo da soma dos valores e a multiplicacao\n    for(i=0;i<lin;i++)\n        for(j=0;j<col;j++)\n            mulp[i][j]=(mat1[i][j]+mat2[i][j])*ru;\n\n    printf(\"\\nMatriz resultante:\\n\");\n    for(int i=0;i<lin;i++) {\n        for(int j=0;j<col;j++) {\n            printf(\"%d\\t\", mulp[i][j]); \n        }\n        printf(\"\\n\");\n    }\n    \n    system(\"pause\");\n    return 0;\n}<\/code><\/pre>\n\n\n\n
    Teste o c\u00f3digo online em: https:\/\/ideone.com\/wFTHzF<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
    A solicita\u00e7\u00e3o de algoritmo foi enviada por Hedson Ferreira. A solicita\u00e7\u00e3o foi enviada por coment\u00e1rio no blog e n\u00e3o foi enviada corretamente conforme solicito (veja a forma correta aqui), mas resolvi atender mesmo assim. O enunciado \u00e9 o seguinte: Fa\u00e7a um algoritmo em linguagem C com as seguintes funcionalidades: Receba duas matrizes como dados e entrada. […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"footnotes":""},"categories":[3,58],"tags":[52],"class_list":["post-764","post","type-post","status-publish","format-standard","hentry","category-c","category-codigo-com-analise","tag-solicitacao-de-algoritmo"],"aioseo_notices":[],"amp_enabled":true,"_links":{"self":[{"href":"http:\/\/www.galirows.com.br\/meublog\/programacao\/wp-json\/wp\/v2\/posts\/764","targetHints":{"allow":["GET"]}}],"collection":[{"href":"http:\/\/www.galirows.com.br\/meublog\/programacao\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/www.galirows.com.br\/meublog\/programacao\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/www.galirows.com.br\/meublog\/programacao\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/www.galirows.com.br\/meublog\/programacao\/wp-json\/wp\/v2\/comments?post=764"}],"version-history":[{"count":4,"href":"http:\/\/www.galirows.com.br\/meublog\/programacao\/wp-json\/wp\/v2\/posts\/764\/revisions"}],"predecessor-version":[{"id":1042,"href":"http:\/\/www.galirows.com.br\/meublog\/programacao\/wp-json\/wp\/v2\/posts\/764\/revisions\/1042"}],"wp:attachment":[{"href":"http:\/\/www.galirows.com.br\/meublog\/programacao\/wp-json\/wp\/v2\/media?parent=764"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/www.galirows.com.br\/meublog\/programacao\/wp-json\/wp\/v2\/categories?post=764"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/www.galirows.com.br\/meublog\/programacao\/wp-json\/wp\/v2\/tags?post=764"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}