View difference between Paste ID: MEfFEyW5 and 0g25ugqd

 #include <algorithm>    // std::for_each
-#include <bitset>       // std::bitset
+
-#include <iomanip>      // std::setw
+#include <iterator>     // std::ostream_iterator
 #include <stddef.h>     // ptrdiff_t
 #include <stdexcept>    // std::exception, std::runtime_error
 #include <stdlib.h>     // EXIT_SUCCESS, EXIT_FAILURE
 #include <string>       // std::string, std::wstring
-#include <string>       // std::wstring
+
 #include <vector>       // std::vector
 
 using namespace std;
 typedef ptrdiff_t   Size;
 
 bool throwX( string const& s ) { throw runtime_error( s ); }
 
 template< class C >
 auto rbegin( C& c ) -> decltype( c.rbegin() ) { return c.rbegin(); }
 
 template< class C >
 auto rend( C& c ) -> decltype( c.rend() ) { return c.rend(); }
 
 template< class Elem >
-template< class Container >
+
-Size countOf( Container const& c ) { return end( c ) - begin( c ); }
+
     v.emplace_back( move( newElem ) );
 }
 
 namespace growDirection { enum Enum{ prepend, append }; }
 namespace patternType { enum Enum { pure, gray }; }
 
 struct Options
 {
     growDirection::Enum     direction;
     patternType::Enum       type;
 
     Options(): direction(), type() {}
 
     Options( int const argc, char const* const argv[] )
         : direction()
         , type()
     {
-            if( strcmp( argv[i], "-append" ) == 0 )
+
         {
             if( string( argv[i] ) == "-append" )
             {
-            else if( strcmp( argv[i], "-reflect" ) == 0 )
+
             }
             else if( string( argv[i] ) == "-reflect" )
             {
                 type = patternType::gray;
             }
             else
             {
                 throwX( string() + "Usage: " + argv[0] + " [-reflect][-append]" );
             }
         }
     }
 };
 
 template< class It >
 void addExtendedStringsTo(
     vector<wstring>&    result,
     wchar_t const       d,
     It const            itSourceBegin,
     It const            itSourceEnd,
     growDirection::Enum direction
     )
 {
     for_each( itSourceBegin, itSourceEnd, [&]( wstring const& s )
     {
         result += (direction == growDirection::append? s + d : d + s);
     } );
 }
 
 vector<wstring> extended( vector<wstring> const& patterns, Options const& opt )
 {
     vector<wstring> result;
 
     addExtendedStringsTo(
         result, L'0', begin( patterns ), end( patterns ), opt.direction
         );
 
     switch( opt.type )
     {
     case patternType::pure:
         addExtendedStringsTo(
             result, L'1', begin( patterns ), end( patterns ), opt.direction
             );
         break;
     case patternType::gray:
         addExtendedStringsTo(
             result, L'1', rbegin( patterns ), rend( patterns ), opt.direction
             );
     }
     return result;
 }
 
 void display( vector<wstring> const& patterns )
 {
     for( auto it = begin( patterns); it != end( patterns ); ++it )
     {
         if( it > begin( patterns ) ) { wcout << L" "; }
         wcout << *it;
     }
     wcout << endl;
 }
 
 void cppMain( Options const& options )
 {
     vector<wstring>     patterns( 1, L"" );
 
     for( int i = 1;  i <= 3;  ++i )
     {
         patterns = extended( patterns, options );
         display( patterns );
     }
 }
 
 int main( int argc, char* argv[] )
 {
     try
     {
         cppMain( Options( argc, argv ) );
         return EXIT_SUCCESS;
     }
     catch( exception const& x )
     {
         wcerr << "!" << x.what() << endl;
     }
     return EXIT_FAILURE;
 }