Usuwanie duplikatów z danej tablicy ++

Mam banalne zadanie z którym się męczę już godzinę i mnie coś trafia, bo to linijka algorytmu... Wstyd tutaj prosić, ale siedzę od rana nad takimi zadankami i sobie rozwiązuję, a tu teraz nagle mózg przestał pracować, denerwuję się i już nie wytrzymuję z tym.
Mam coś takiego i brakuje warunku, że jak są takie same, to chcę aby ten t[i] się zrobił pusty, nie wyświetlał nic, był usunięty:

int main(){
			
int t[7]={1,4,1,3,4,6,2};
	for (int i=0;i<7;i++) cout<< t[i];

    for (int i=0;i<7;i++) {
    	for (int j=0;j<7;j++){
    		
    	if(t[i]==t[j]) ;
			
    }
    }
    cout<<endl;
    for (int i=0;i<7;i++) cout<< t[i];
	return 0;
}

Poniżej jest też rozwiązanie inne, ale chcę aby po prostu coś dopisać do tego co jest u góry (co dać w tym if-ie?) a nie robić funkcji.

#define NMAX 7 //wielkosc tablicy
const int ile=NMAX;
int t[ile]={1,4,1,3,4,6,2};

void WyswietlTablice(int tab[],int ile)
{
	cout<<endl;
	for(int i=0;i<ile;i++)
		cout<<"Tab["<<i<<"]="<<tab[i]<<endl;
}

bool CzyJestWczesniej(int tab[],int ile,int wartosc)
{
	for(int i=0;i<ile;i++)
	{
		if(tab[i]==wartosc) return true;
	}
	return false;
}

void Linia()
{
	cout<<endl<<"=============================================="<<endl;
}


int main()
{
    WyswietlTablice(t,ile);
    Linia();
    for(int i=0;i<ile;i++)
    {
    	if(!CzyJestWczesniej(t,i,t[i]))	
    		cout<<"Tab["<<i<<"]="<<t[i]<<endl;	
	}
    
	cin.get(),cin.get(),
	system("PAUSE");
}

(kod wstawiaj w znaczniki <code class="cpp"></code> - msm)

#include <iostream>
#include <algorithm>
#include <iterator>
#include <set>
#include <vector>
using namespace std;

template<typename T, typename InputIterator, typename OutputIterator>
void removeDup(InputIterator begin, InputIterator end, OutputIterator res) {
	set<T> temp(begin, end);
	copy(temp.begin(), temp.end(), res);
}

int main() {
	vector<int> v1 = {1, 1, 2, 3, 3, 4, 4, 3, 3};
	vector<int> res;
	removeDup<int>(v1.begin(), v1.end(), back_inserter(res));
	copy(res.begin(), res.end(), ostream_iterator<int>(cout, "\n"));
	return 0;
}

Jest :) Tylko ten język wykracza ponad podstawy, mało zrozumiały dla mnie :) Ale wielki PLUS i dzięki dla n0name.

 #include <iostream>

using namespace std;

int main(){
int n=7; 
int t[7]={1,4,1,3,4,6,2};
    for (int i=0;i<7;i++) cout<< t[i]<< endl;
 
	for(int i=0; i<n; i++)
	for(int j=i+1; j<n; j++)
	   {if(t[i]==t[j]) t[j]=0;}
	   for(int i=0; i<n; i++)
	   {if(t[i]==0) ; else cout << t[i] << ";";}
	   	
	cin.get(),cin.get(),
	system("PAUSE");
}

dało radę, trzeba było jeszcze 3 fora dać, ale zjadło mi to nerwów.

int main()
  {
   int t[7]={1,4,1,3,4,6,2};
   for(int i=0;i<sizeof(t)/sizeof(*t);++i) cout<<t[i]<<' ';
   cout<<endl;
   int p=0;
   for(int i=0;i<sizeof(t)/sizeof(*t);++i)
      {
       int k,v=t[i];
       for(k=0;k<p;++k) if(t[k]==v) break;
       if(k>=p) t[p++]=v;
      }
   for(int i=0;i<p;++i) cout<<t[i]<<' ';
   return 0;
  }

Użycie std::set będzie najlepsze (czyli rozwiązanie @n0name_l), ewentualnie możesz użyć std:

 
template<typename T>
void removeDuplicates(std::vector<T>& vec)
{
    std::sort(vec.begin(), vec.end());
    vec.erase(std::unique(vec.begin(), vec.end()), vec.end());
}

przy callowaniu metod template, compilator powinien sam umieć wydedukować typ Panowie -> http://ideone.com/jCxOjE

ten nie umie http://ideone.com/cSLcq0

Kompilator sobie radzi jedynie z parametrami funkcji.

@gośćabc - czepiasz się wywoływania metod/funkcji z jawnie podanym typem, a zarazem przedstawiasz kompletnie beznadziejną implementację funkcji usuwającej powtarzające się elementy w tablicy :/

chodziło o pokazanie usuwania elementu wraz ze sprawdzeniem czy istnieje

stąd takie rozwiązanie

to nie jest czepianie się, jak używasz templates to używaj templates poprawnie, jednocześnie ja mógłbym wyśmiać Twoje beznadziejne rozwiązanie ponieważ nie wpadłes na najprostsze czyli http://ideone.com/fZP7K0

A co jest niepoprawnego w jawnym specyfikowaniu parametrow?

jednym chyba z najważniejszych argumentów jest to, że gdy typ Ci się zmieni, to zmiany dokonujesz tylko w 1 miejscu zamiast w 20

dlatego cała dedukcja typów powinna odbywac się w funkcji, a nie byc podawana poza nią, zagwarantuje ci to spójność kodu oraz jego przenaszalność pomiędzy różnymi projektami

tylko tyle

Przecież wyraźnie napisałem, że użycie std::set będzie najlepszym rozwiązaniem.
Mieszasz poziomy abstrakcji, przedstawiasz "najbrutalniejsze" rozwiązanie, zwracasz wynik przez kopie (pomijam, że najprawdopodobniej zadziała RVO). Jeśli to dla ciebie dobry przykład rozwiązania, to aż się boję zapytać o zły ;)

a Twoje to jakie jest? najmniej brutalne? http://i.imgur.com/9uHz7FN.png

bez spiny, wszyscy się tutaj uczymy, ja także,

chciałem jedynie wspomnieć o tym, że można sobie zaoszczędzić duzo roboty chowająć dedukcję do funkcji

rekompilowanie kodu wber pozorom może być bardzo uciążliwe

ednym chyba z najważniejszych argumentów jest to, że gdy typ Ci się zmieni, to zmiany dokonujesz tylko w 1 miejscu zamiast w 20

Sure, zgadzam sie. Jednak, zeby to sprawnie napisac potrzeba jednak znacznie wiecej kodu. Stad pewien kompromis pomiedzy rozszerzalnoscia i reuzywalnoscia, a demonstracja przykladu.
W sensownej aplikacji jednak wolalbym sie trzymac z dala od calego pomyslu tych iteratorow, jak i luznych funkcji.

pewnie

nalezy korzystać z naprostszych rozwiązań

czyli bez templates tutaj :)

gośćabc napisał(a):

a Twoje to jakie jest? najmniej brutalne? http://i.imgur.com/9uHz7FN.png

Tutaj masz odpowiedź: http://ideone.com/YUQA93
Btw, nikt się tutaj nie spina ;)

#include <iostream>
#include <algorithm>

using namespace std;

int main()
{
  int t[7] = { 1, 4, 1, 3, 4, 6, 2};
  int n = sizeof(t) / sizeof(int);
  
  cout << "Przed zmiana:\n";
  for (int i=0; i < n; i++) cout<< t[i] << "\n";
  
  cout << "\nUnikatowe:\n";
  sort(t, t + 7);
  n = unique(t, t + 7) - t;
  for (int i = 0; i < n; i++) cout<< t[i] << "\n";
  return 0;
}