nearest.cc
changeset 89 66f0244c2863
parent 88 91fbc3ea240b
equal deleted inserted replaced
88:91fbc3ea240b 89:66f0244c2863
     8 #include <vector>
     8 #include <vector>
     9 #include <algorithm>
     9 #include <algorithm>
    10 #include <stdexcept>
    10 #include <stdexcept>
    11 #include <iomanip>
    11 #include <iomanip>
    12 
    12 
    13 using namespace std;
       
    14 
       
    15 typedef short MYTYPE;
    13 typedef short MYTYPE;
    16 
    14 
    17 namespace cute {
    15 namespace cute {
    18     template <typename Iter, typename T>
    16     template <typename Iter, typename T>
    19     Iter find (Iter begin, Iter end, const T& query)
    17     Iter find (const Iter begin, const Iter end, const T& query)
    20     {
    18     {
    21         Iter it;
    19         Iter it;
    22 
    20 
    23         for (it = begin; it != end; it++) {
    21         for (it = begin; it != end; it++) {
    24             if (*it == query)
    22             if (query == *it)
    25                 return it;
    23                 return it;
    26         }
    24         } return it;
    27         return it;
       
    28     }
    25     }
    29 
    26 
    30     template <typename Iter, typename T>
    27     template <typename Iter, typename T>
    31     void nearest (Iter begin, Iter end, const T& query)
    28     void nearest (const Iter begin, const Iter end, const T& query)
    32     {
    29     {
    33         Iter it, current;
    30         Iter it, current;
    34 
    31 
    35         current = it = cute::find (begin, end, query);
    32         current = it = cute::find (begin, end, query);
    36         if (current == end)
    33         if (current == end)
    37             return;
    34             return;
    38 
    35 
    39         while (current != end) {
    36         while (current != end) {
    40             cout << *current << endl;
    37             std::cout << *current << std::endl;
    41             current++;
    38             current++;
    42         }
    39         }
    43 
    40 
    44         current = --it;
    41         current = --it;
    45 
    42 
    46         do {
    43         do {
    47             cout << *current << endl;
    44             std::cout << *current << std::endl;
    48         } while ((current--) != begin);
    45         } while ((current--) != begin);
    49     }
    46     }
    50 }
    47 
       
    48     template <class C, class T>
       
    49     typename C::iterator nearest (C& con, const T& query)
       
    50     {
       
    51         typename C::iterator it;
       
    52 
       
    53         for (it = con.begin (); it != con.end (); it++) {
       
    54             if (query == *it)
       
    55                 return it;
       
    56         }
       
    57         return it;
       
    58     }
       
    59 };
       
    60 
       
    61 using namespace std;
    51 
    62 
    52 int main (int argc, char **argv)
    63 int main (int argc, char **argv)
    53 {
    64 {
    54     MYTYPE value, query;
    65     MYTYPE value, query;
    55     vector <MYTYPE> vec;
    66     vector <MYTYPE> vec;
    56     list <MYTYPE> lis;
    67     list <MYTYPE> lis;
    57 
    68 
    58     for (int i = 0; i < 10; i++) {
    69     for (int i = 0; i < 10; i++) {
    59         cout << "[" << std::setw (2) << i << "] Enter a value: ";
    70         cout << "[" << std::setw (2) << i << "] Enter a value: ";
    60         cin >> value;
    71         cin >> value;
    61         if (!cin)
    72         if (cin) {
    62             throw std::runtime_error ("BAD_INPUT");
       
    63         else {
       
    64             vec.push_back (value);
    73             vec.push_back (value);
    65             lis.push_back (value);
    74             lis.push_back (value);
    66         }
    75         } else
       
    76             throw runtime_error ("BAD INPUT");
    67     }
    77     }
    68 
    78 
    69     sort (vec.begin (), vec.end ());
    79     sort (vec.begin (), vec.end ());
    70     lis.sort ();
    80     lis.sort ();
    71 
    81 
    73     cin >> query;
    83     cin >> query;
    74 
    84 
    75     cute::nearest (vec.begin (), vec.end (), query);
    85     cute::nearest (vec.begin (), vec.end (), query);
    76     cute::nearest (lis.begin (), lis.end (), query);
    86     cute::nearest (lis.begin (), lis.end (), query);
    77 
    87 
       
    88     cute::nearest (lis, query);
       
    89 
    78     return 0;
    90     return 0;
    79 }
    91 }