Devolver o índice das colunas que tiverem zeros em uma matriz

[msmsms]

objectivo 1: devolver as colunas cujos os seus valores sejam todos zero => JÁ ESTA

objectivo 2: pegar nessas colunas e passar as linhas com mesmo indice a zeros e devolver as proximas colunas a zeros que resultam desta modificação=> AINDA PRECISO DE AJUDA !

#include<iostream>
#include<stdlib.h>
#include<math.h>
#include<locale.h>
using namespace std;
char m[4][4] = {{0,1,0,1},
{0,0,0,1},
{0,1,0,1},
{0,1,0,0}};
int l=2;

int main(){
setlocale(LC_ALL, "");
int cont = 0;
for (int c=0;c<4;c++){
for (int l=0;l<4;l++){
if(m[l][c]==0)
cont = cont + 1;
}
if (cont==4)
cout << c << endl;
cont = 0;
}
system("pause");
return 0;
}

Edited March 7, 2015 at 01:08 AM by msmsms

[thoga31]

Um conselho: convém explicares melhor as tuas dúvidas. Para ti, elas são óbvias, mas nós não estamos a realizar o trabalho que tu estás a resolver. Portanto, para alguém te poder ajudar, convém estar a par do que estás a fazer da forma adequada.

Após ler e reler os dois objectivos que descreveste, creio ter entendido o que pretendes.

Quando verificas que uma coluna é composta apenas por zero, não estás a armazenar essa informação em lado nenhum, mas sim a colocá-la no cout, ou seja, no monitor, local onde a informação não será propriamente "utilizável". Por conseguinte, deverás ter uma forma de guardar os índices das colunas cujo conteúdo é constituído apenas por zeros - um array, porventura.

Usando esses índices, aplicas dois ciclos encadeados (em tudo semelhantes ao que já tens feito) para aceder às linhas e atribuis o valor a zero.

No final, repetes o procedimento inicial, que já tens feito. Aqui, eu aconselho o uso de uma função de forma a que não estejas a fazer Copy-Paste de código, o que não é, de todo, elegante e muito menos desejável.

Caso tenhas alguma dúvida, coloca-se de forma clara e objectiva de forma a que os membros que entendam do assunto te possam responder e, consequentemente, ajudar.

Caso tenhas dúvidas agora, talvez necessites de esperar até de manhã porque já passam das 2 horas da madrugada.

Cumprimentos.

Edited March 7, 2015 at 02:03 AM by thoga31

[msmsms]

no caso desse exemplo apenas temos 2 colunas e se elas fossem 1000

se usar um vector auxiliar para guardar os indices das colunas a transformar em 0 nas linhas não da para todos os casos

se eu definir um o tamanho de vetor como 1000 e mesmo percorrendo as 1000 posisões para obter os valores de indices eu acabo com um problema que é o valor zero guadado no vetor

quando vou imprimir para todos os casos o zero estara sempre incluido nas muitas posições porque o vetor foi iniciado a zero

por isso estou com bastante confusao para saber como fazer

ja fiz aqui imensos testes e deu sempre broncas

preciso mesmo de umas dicas resultem para um caso generico

[pwseo]

msmsms,

Antes de te responder, vou fazer um pequeno desvio que considero importante.

Uma vez que estás a escrever código C++ deverias fazer um esforço por não o misturar tanto com código C, ou seja:

// Estas linhas:
#include<stdlib.h>
#include<math.h>
#include<locale.h>

// ...deveriam ser substituídas por estas:
#include <cstdlib>
#include <cmath>
#include <clocale>

Além disso, em C++ o return 0 no final da função main é implícito, pelo que podes simplesmente omiti-lo se o teu programa devolver sempre esse valor.

E agora volto à tua questão. Tal como o thoga31, tive que reler a questão para compreender o que pretendes; não é que seja um problema de difícil compreensão, a tua explicação é que não foi a mais clara.

Esquematizando, entendi que pretendes fazer o seguinte:

0 1 0 1       0 0 0 0
0 0 0 1  >>>  0 0 0 1
0 1 0 1  >>>  0 0 0 0
0 1 0 0       0 1 0 0

Ou seja, temos uma matrix 4x4 na qual identificamos as colunas 0 e 2 como sendo compostas por apenas zeros.

Agora vamos transformar as linhas da matrix com esses índices (0 e 2) em linhas com apenas zeros também. Correcto?

O thoga31 já te indicou que deves armazenar o número das colunas em algum lado, ao que respondeste que terias problemas se tivesses que armazenar 1000 colunas.

Existem várias formas de contornar este problema. A solução mais simples é definires um limite máximo para o número de colunas e criares um array com esse tamanho, no qual cada posição representará se a coluna com essa posição tem ou não apenas zeros:

// Máximo de 512 colunas (e linhas)
const int MAXCOLS = 512;
// Inicializar zcol com 512 zeros.
bool zcol[MAXCOLS] = { 0, };

// Para dizeres que a coluna #4 era composta por apenas zeros, farias apenas:
zcol[4] = true;

Outra solução passa pela utilização da classe vector da linguagem C++ que te permite ter um array que vai aumentando de tamanho automaticamente:

// Exemplo de como utilizar vectors em C++11
#include <iostream>
#include <vector>

using namespace std;

int main() {
 vector<int> arr { 0, 2 };
 arr.push_back(42);

 for (auto &i : arr)
   cout << i << endl;
}

// O output será:
// 0
// 2
// 42

Outra solução passa por detectar primeiro o número de colunas da matriz e criar um array de bool com esse tamanho:

ncol = ... // determinar o número de colunas da matriz
bool *zcol = new bool[ncol];

...

delete[] zcol;

Neste array zcol cada posição poderia assumir os valores true ou false consoante a coluna com essa posição fosse ou não composta por apenas zeros.

Ainda outra solução seria fazer exactamente o mesmo mas utilizando as funções malloc e free. Uma vez que estamos a utilizar C++ não precisamos de fazer o desvio para esta solução.

Uma última observação: se isto não é o que pretendes, então sugiro vivamente que refiras mais detalhes sobre a tua questão, nomeadamente sobre qual é o resultado final que pretendes e até mesmo possíveis resultados intermédios que possam ser úteis para uma compreensão melhor do problema.

De facto, não consegui perceber a maior parte do teu último post, só mesmo a questão de ter 2 colunas ou 1000 colunas (que respondi acima).

se usar um vector auxiliar para guardar os indices das colunas a transformar em 0 nas linhas não da para todos os casos

Quais são os casos em que não funciona? Não te limites a tocar neles superficialmente, tens que explicar devidamente esses casos

se eu definir um o tamanho de vetor como 1000 e mesmo percorrendo as 1000 posisões para obter os valores de indices eu acabo com um problema que é o valor zero guadado no vetor

Este era um dos casos que referiste anteriormente? Se sim, não o compreendi; preciso de detalhes objectivos.

quando vou imprimir para todos os casos o zero estara sempre incluido nas muitas posições porque o vetor foi iniciado a zero

O mesmo que disse em cima.

por isso estou com bastante confusao para saber como fazer

ja fiz aqui imensos testes e deu sempre broncas

preciso mesmo de umas dicas resultem para um caso generico

E nós (eu, pelo menos) estamos confusos com a tua descrição. Que testes realizaste e que erros obtiveste? Sem esse tipo de informação é inútil estarmos aqui a mandar palpites.

Precisamos mesmo que sejas mais claro e objectivo.

[msmsms]

pwseo sim é isso que pretendo

eu vou ler com mais atenção a resposta

ja fiz o que o thoga31 recomendou uma função à parte para obter as colunas

se não conseguir ajeitar o vetor para mudar as colunas para linhas eu deixo o meu novo código mais tarde

obrigado!

[msmsms]

eu continuo encrencado na parte de transformar linhas com 1's totalmente a 0's

função alterar_linhas()

não sei se a forma de como estive o dia de hoje a tentar solucionar o problema vai dar a solução

era bom obter uma opinião

penso que para voltar a percorrer as colunas tenho de ter um outro vector auxiliar que me permita registar as colunas já consideradas nas etapas anteriores e gerei mais um vector auxiliar desta vez com o nome elimina

entretanto com tantas coisas a ter em atenção não sei o que mais fazer nas funções obter_colunas() e alterar_linhas()

por forma a obter o output esperado, que neste caso com esta nova matriz será:

// dia 1: 0 6

// dia 2: 1 2 7

// dia 3: 3 9

// dia 4: 4 5 9

o certo é que eu já consigo com este programa obter: 0 6

mas não consigo passar disso

#include<iostream>
#include<stdlib.h>
#include<math.h>
#include<locale.h>
//#include<array>
using namespace std;
#define MAX 5000 // deve suportar uma matriz ate 5000 colunas ou 5000 linhas
int l=2;
int m = 10; // maximo de colunas
///////////////////////////////////////////////
// uma das matrizes a ser validada
char adj[MAX][MAX] = {{0,1,1,0,0,0,0,0,0,0}, // l=0
      {0,0,0,1,0,0,0,0,0,0}, // l=1
      {0,0,0,0,0,1,0,0,0,0}, // l=2
      {0,0,0,0,1,1,0,0,0,0}, // l=3
         {0,0,0,0,0,0,0,0,0,0}, // l=4
         {0,0,0,0,0,0,0,0,0,0}, // l=5
      {0,0,0,0,0,0,0,1,0,0}, // l=6
      {0,0,0,0,0,0,0,0,1,1}, // l=7
      {0,0,0,0,0,0,0,0,0,0}, // l=8
      {0,0,0,0,0,0,0,0,1,0}  // l=9
     };
// OUTPUT ESPERADO:
// dia 1: 0 6    
// dia 2: 1 2 7
// dia 3: 3 9
// dia 4: 4 5 9

int v[MAX] = {0}; // deve considerar o zero apenas quando necessario
int elimina[MAX] = {0}; // para guardar as colunas já tratadas e não as voltar a considerar
struct conserva{ // ainda não sei se é necessário
int dia;
int topicos[MAX];
};
struct conserva guardar, *link;
void obter_colunas(){
int cont = 0;
for (int c=0;c<m;c++){ // c=0 c=1 c=2 c=3 c=4 c=5 c=6 c=7 c=8 c=9
 for (int l=0;l<m;l++){
  if(adj[l][c]==0)
   cont = cont + 1;
 }
 if (cont==m)
  // incremento aqui 1 para conseguir anular os zeros que estao de origem no vetor
  // posteriormente em alterar_linhas() subtrai-se 1
  v[c] = c+1;
 if (v[c] != 0)
  cout << v[c]-1 << endl; // apenas para teste
  elimina[i] = v[i]-1;
 cont = 0;
}
}
int contar_dias = 0; // contar os dias que ultrapassem o limite (l)
void alterar_linhas(){
for (int i=0; i<m; i++){ // percorrer o vetor obtido em obter_colunas()
 for (int l=0;l<m;l++){ // percorrer a matriz por linhas
  for(int c=0;c<m;i++){ // percorrer a matriz por colunas
   if (l == v[i]-1) // se a linha for igual a algum valor do vetor
    // alterar os valores de toda esta linha para zero
    adj[l][c] = 0; 
  }
 }
}

//limpar o vetor v
for (int i=0; i<MAX; i++){
 if (v[i] !=0)
  v[i] = 0;
}
}
int main(){
setlocale(LC_ALL, "");
obter_colunas();
system("pause");
return 0;
}

Edited March 7, 2015 at 10:14 PM by msmsms

[HappyHippyHippo]

podes fazer o favor de apresentar o enunciado ?

é que existe uma maneira mais fácil de resolver o problema ...

[msmsms]

podes fazer o favor de apresentar o enunciado ?

é que existe uma maneira mais fácil de resolver o problema ...

eu já tenho a etapa dos inputs e obtenção da matriz de adjacência através desses inputs feita

só me falta mesmo obter os ouputs através da matriz de adjacência o que está a ser muito difícil para mim

por isso fiz este código à parte já com a matriz dentro do corpo do código para simplificar e obter ajuda mais directa

tens a certeza que existe uma maneira mais simples?

Edited March 9, 2015 at 05:58 PM by msmsms

[HappyHippyHippo]

claro que existe uma maneira mais simples de fazer o que pretendes.

o problema fulcral é que tu não deste hipótese de variar a resolução do problema, e foi por essa razão que pedi o enunciado.

olha para o que escreveste aqui:

objectivo 2: pegar nessas colunas e passar as linhas com mesmo indice a zeros e devolver as proximas colunas a zeros que resultam desta modificação=> AINDA PRECISO DE AJUDA !

dizes que tens de fazer isso, mas na realidade o processo é muito mais simples se não tiver as restições que ditas nessa linha (devolver as linhas, etc ...)

isto porque fica implícito que pretendes ter dois passos dstintos:

- saber que linhas tem tudo a zero

- alterar as colunas com esses indices para tudo a zero.

a questão é que se não for dois passos distintos, tudo fica muito mais simples:

iterar por todas as linhas da matriz
 iterar por todas as colunas da matrix
   somar os valores das colunas iteradas
 se o somatório for zero
   iterar todas as linhas da matriz
     atribuir o valor de zero à célula da linha iterada pela coluna de número correspondente à linha iterada no ciclo mais exterior

prontos ... tudo feito de uma vez.

nota : não sei o que pretendes fazer assim como o procesos é o necessário para o realizar. o comentário é relativo somente à questão colocada no tópico.

[msmsms]

iterar por todas as linhas da matriz
iterar por todas as colunas da matrix
somar os valores das colunas iteradas
se o somatório for zero
iterar todas as linhas da matriz
atribuir o valor de zero à célula da linha iterada pela coluna de número correspondente à linha iterada no ciclo mais exterior

eu não consigo entender o que dizes

estás a dizer para eu percorrer a matriz por linhas e depois por colunas

for (linhas)

for(colunas)

e o depois não entendo o resto, onde é que entra ai a utilização da matriz de adjacência adj[l][c] ?

[HappyHippyHippo]

eu não consigo entender o que dizes

não posso fazer mais ... seria escrever o código todo ...

e o depois não entendo o resto, onde é que entra ai a utilização da matriz de adjacência adj[l][c] ?

nota : não sei o que pretendes fazer assim como o procesos é o necessário para o realizar. o comentário é relativo somente à questão colocada no tópico.