Wyszukwanie takich samych liczb elementów w zbiorze C++

Question

Cześć. Mam do napisania program, który wyszukuje elementy w zbiorze. I o ile nie mam problemu ze znalezieniem dwóch takich samych liczb, o tyle wyszukanie pary liczb, które są do siebie przeciwne sprawia mi już problem. Podrzuci ktoś jakiś pomysł, jak się za to wziąć?

#include<iostream>

using namespace std;

void choice(int x)
{
	int p = 0, k =0;
	int  tab[11] = { 66, -3, 5, 8, -2, 7, 13, 66, 3, 7, 2 };
	switch (x)
	{
	case 1:
		for (int i = 0; i < 10; i++)
		{
			if (tab[i] > 0)
				cout << tab[i] << " ";
		}
		break;
	case 2:
		for (int i = 0; i < 10; i++)
		{
			for (int j = i + 1; j < 10; j++)
			{
				if (tab[i] == tab[j])
					cout << tab[j] << " ";
			}
		}
		break;
	case 3:
		for (int i = 0; i < 10; i++)
		{
			for (int j = i + 1; j < 10; j++)
			{
				if (tab[i], tab[j] > 0)
				{
					if (tab[i] == tab[j])
						cout << tab[j] << " ";
				}
				
			}

		}
	}
}
int main()
{
	int x;
	
	cout << "Podaj numer operacji, jaka chcesz wykonac" << endl;
	cout << "1. Wypisz dodatnie" << endl << "2. Wypisz elementy unikalne" << endl;
	cout << "3. Wypisz elementy unikalne gdy x = x oraz x = -x" << endl;
	cout << "4. Wypisz elementy unikalne gdy x = -x" << endl;
	cin >> x;
	choice(x);
	system("PAUSE");
	return 0;
}

 

Comments

Jak x = -x? Chyba nieporadnie zapisałeś jakąś zależność. Lepiej to popraw.

---

x = -x oznacza, że ze zbioru poszukuje przeciwieństw tj. 5 = -5

---

Ale nadal zapis 5 = -5 jest błędny logicznie. Te wartości nie są sobie równe. Lepiej napisz, że dana operacja szuka elementów unikalnych, które posiadają pary z elementami przeciwnymi.

---

taki zapis tez chyba nie ma wiekszego sensu

if (tab[i], tab[j] > 0)

 

---

"2. Wypisz elementy unikalne"

Tablica: { 66, -3, 5, 8, -2, 7, 13, 66, 3, 7, 2 }

Output: 66 7

Co tu się dzieje :O

---

Ale co musisz podać na wyjściu? Indeksy par, czy tylko wartości?

Answer 1

Moja propozycja do dalszej nauki i analizy (w C++)

#include <iostream>
#include <vector>
#include <ctime>
#include <cstdlib>
#include <random>
#include <algorithm>
#include <new>
#include <unordered_map>

class NastepnyMojInt {
private:
    const int v;

public:
    NastepnyMojInt(const int v): v(v) {
    }
    bool operator == (const NastepnyMojInt &other) const {
        return abs(v) == abs(other.v);
    }
    int get() const {
        return v;
    }
    void operator = (const NastepnyMojInt &other) {
        new(this) NastepnyMojInt(other.v);
    }
    std::size_t operator()() const {
          return std::hash<int>()(abs(v));
    }

};

namespace std {

  template <>
  struct hash<NastepnyMojInt>
  {
    std::size_t operator()(const NastepnyMojInt& k) const
    {
      return k();
    }
  };

}


class MyException : public std::exception {
private:
    const std::string swhat;

public:
    MyException( const char *const swhat ) : swhat(swhat) {
    }

    virtual const char* what() const throw(){
        return swhat.c_str();
    }
};

static int getSize() {
    std::cout << "Podaj rozmiar: ";
    int n;
    std::cin >> n;
    if( std::cin.fail() || n < 1) {
        throw MyException("Nieprawidłowy rozmiar");
    }
    return n;
}


static int getMin() {
    std::cout << "Podaj minimum przedziału: ";
    int n;
    std::cin >> n;
    if( std::cin.fail() ) {
        throw MyException("Nieprawidłowe minimum");
    }
    return n;
}

static int getMax(const int min) {
    std::cout << "Podaj maksimum przedziału: ";
    int n;
    std::cin >> n;
    if( std::cin.fail() || n < min ) {
        throw MyException("Nieprawidłowe maksimum");
    }
    return n;
}


int main(int argc, char *argv[]) {
    (void)argc;
    (void)argv;
    try {
        std::vector<int> rnds;
        const int seed = (int)time(NULL);
        std::cout << "seed = " << seed << std::endl;
        const int size = getSize();
        const int min = getMin();
        const int max = getMax(min);
        std::ranlux48 generator( seed );
        std::uniform_int_distribution<int> distribution(min,max);
        for( int i=0 ; i<size ; i++ ) {
            rnds.push_back( distribution(generator) );
        }
        for( int i=0 ; i<rnds.size() ; i++ ) {
            std::cout << i << " " << rnds[i] << std::endl;
        }
        std::unordered_map<NastepnyMojInt, std::vector<int> > map;
        for( int i=0 ; i<rnds.size() ; i++ ) {
            NastepnyMojInt mint(rnds[i]);
            if( map.count( mint ) == 0 ) {
                map[mint] = std::vector<int>( 1 , i );
            } else {
                map[mint].push_back(i);
            }
        }
        for( auto i=map.cbegin() ; i!=map.cend() ; ++i ) {
            for( auto j=i->second.cbegin() ; j!=i->second.cend() ; ++j ) {
                std::cout << "rnds[" << *j << "] == " << rnds[*j] << ", ";
            }
            std::cout << std::endl;
        }

    }
    catch( std::exception &e ) {
        std::cout << "Wystapił błąd: " << e.what() << std::endl;
    }
    return 0;
}