Freestyle Sparring

x = rand(1..100)
y = rand(1..100)

describe "Solution" do
  it "find stray" do
    Test.assert_equals(find_stray([x,y,y]), x, "[x,y,y] works")
    Test.assert_equals(find_stray([x,y,y,y]), x, "[x,y,y,y] DOSE NOT works")
    Test.assert_equals(find_stray([x,y,y,y,y]), x, "[x,y,y,y,y] works")
  end
  it "find stray optimized" do
    Test.assert_equals(find_stray_o([x,y,y]), x, "[x,y,y] works")
    Test.assert_equals(find_stray_o([x,y,y,y]), x, "[x,y,y,y] DOSE NOT works")
    Test.assert_equals(find_stray_o([x,y,y,y,y]), x, "[x,y,y,y,y] works")
  end
end

#include <list>
#include <tuple>
#include <utility>
#include <vector>

template <class... Args> void printInput(const char* name, const Args&... args);
#define alwaysTrue(...) (printInput("alwaysTrue", __VA_ARGS__), alwaysTrue(__VA_ARGS__))

Describe(codewarriors) {
  It(do_print_arguments) {
    using vi = std::vector<int>;
    using li = std::list<int>;
    using vvi = std::vector<std::vector<int>>;
    using vs = std::vector<std::string>;
    using pii = std::pair<int, int>;
    Assert::That(alwaysTrue(vi{0, 1, 2}), Is().True());
    Assert::That(alwaysTrue(li{0, 1, 2}), Is().True());
    Assert::That(alwaysTrue((int[]){0, 1, 2}), Is().True());
    Assert::That(alwaysTrue(vvi{{0, 1, 2}, {0, 1}, {1}}), Is().True());
    Assert::That(alwaysTrue("012"), Is().True());
    Assert::That(alwaysTrue((const char*)"012"), Is().True());
    Assert::That(alwaysTrue(std::string{"012"}), Is().True());
    Assert::That(alwaysTrue(vi{0, 1, 2}, "012", 123), Is().True());
    Assert::That(alwaysTrue(vs{"a", "b", ""}, 'c'), Is().True());
    Assert::That(alwaysTrue("pair", std::make_pair(1, "2")), Is().True());
    Assert::That(alwaysTrue("tuple", std::make_tuple(1, "2", '3', vi{1})), Is().True());
    Assert::That(id(pii{0, 1}), Equals(pii{0, 1}));
  }
};



#include <cstddef>
#include <algorithm>
#include <iostream>
#include <iterator>
#include <ostream>
#include <type_traits>
#include <utility>

#include <tuple>

template <class... Ts> struct make_void { using type = void; };
template <class... Ts> using void_t = typename make_void<Ts...>::type;

template <class, class = void> struct is_container : std::false_type { };
template <class T> struct is_container<T, void_t<decltype(std::cbegin(std::declval<T>()))>> : std::true_type { };

template <class, class = void> struct is_string : std::false_type { };
template <class T> struct is_string<T, std::enable_if_t<std::is_same<decltype(*std::cbegin(std::declval<T>())), const char&>::value>> : std::true_type { };

struct ArgumentPrinter {
  std::ostream& os;
  
  template <class Arg, std::enable_if_t<!is_container<Arg>::value && !is_string<Arg>::value>* = nullptr>
  void printArg(const Arg& arg) {
    os << arg;
  }
  
  void printArg(const char arg) {
    os << "'" << arg << "'";
  }
  
  void printArg(const char* const arg) {
    os << '"' << arg << '"';
  }
  
  
  template <class Arg, std::enable_if_t<is_string<Arg>::value>* = nullptr>
  void printArg(const Arg& arg) {
    os << '"';
    std::copy(std::cbegin(arg), std::cend(arg), std::ostreambuf_iterator<char>(os));
    os << '"';
  }
  
  template <class T1, class T2>
  void printArg(const std::pair<T1, T2>& arg) {
    os << "{";
    printArgs(arg.first);
    os << ", ";
    printArgs(arg.second);
    os << "}";
  }
  
  #include <tuple>
  template <typename T, std::size_t... Is>
  void printArgsApplyImpl(const T& arg, std::index_sequence<Is...>) {
    printArgs(std::get<Is>(arg)...);
  }
  template <typename... Ts> 
  void printArgsApply(const std::tuple<Ts...>& arg) {
    printArgsApplyImpl(arg, std::make_index_sequence<std::tuple_size<std::tuple<Ts...>>::value>());
  }
  template <class... Ts>
  void printArg(const std::tuple<Ts...>& arg) {
    os << "{";
    printArgsApply(arg);
    os << "}";
  }
  
  template <class Arg, std::enable_if_t<is_container<Arg>::value && !is_string<Arg>::value>* = nullptr>
  void printArg(const Arg& arg) {
    const auto b = std::cbegin(arg), e = std::end(arg);
    os << "{";
    for (auto i = b; i != e; ++i) {
      if (i != b)
        os << ", "; 
      printArgs(*i);
    }
    os << "}";
  }
  
  template <class Arg>
  void printArgs(const Arg& arg) {
    printArg(arg);
  }
  
  template <class Arg, class... Args>
  void printArgs(const Arg& arg, const Args&... args) {
    printArgs(arg);
    os << ", ";
    printArgs(args...);
  }
};

template <class... Args>
void printInput(const char* name, const Args&... args) {
  std::cout << name << "(";
  ArgumentPrinter{std::cout}.printArgs(args...);
  std::cout << ")\n";
}


#define DEFINE_STRINGIZER(type) \
namespace snowhouse {\
  template <> struct Stringizer<type> {\
    static std::string ToString(const type& x) {\
      std::ostringstream oss;\
      ArgumentPrinter{oss}.printArg(x);\
      return oss.str();\
    }\
  };\
}

#define COMMA ,
DEFINE_STRINGIZER(std::pair<int COMMA int>)