From 32d627eb996761c052b5b0f55a7294e799a2f51d Mon Sep 17 00:00:00 2001
From: "Bradley M. Small" <bsmall@bsmall-4600>
Date: Tue, 24 Sep 2013 08:25:29 -0400
Subject: [PATCH] initial checkin
---
Makefile | 28 +++++++++++++++
codeseries.zip | Bin 0 -> 4638 bytes
combo.cpp | 57 ++++++++++++++++++++++++++++++
combo.h | 23 ++++++++++++
cut.cpp | 56 +++++++++++++++++++++++++++++
cut.h | 27 ++++++++++++++
main.cpp | 58 ++++++++++++++++++++++++++++++
tests.cpp | 93 +++++++++++++++++++++++++++++++++++++++++++++++++
tests.h | 19 ++++++++++
unit_test.cpp | 52 +++++++++++++++++++++++++++
10 files changed, 413 insertions(+)
create mode 100644 Makefile
create mode 100644 codeseries.zip
create mode 100644 combo.cpp
create mode 100644 combo.h
create mode 100644 cut.cpp
create mode 100644 cut.h
create mode 100644 main.cpp
create mode 100644 tests.cpp
create mode 100644 tests.h
create mode 100644 unit_test.cpp
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..16e6d63
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,28 @@
+DEPS=combo.h cut.h Makefile tests.h
+SRCS=combo.cpp cut.cpp main.cpp tests.cpp
+BIN=main.bin
+OBJS = $(SRCS:.cpp=.o)
+
+TEST_SRCS=unit_test.cpp combo.cpp cut.cpp tests.cpp
+TEST_BIN=unit_test.bin
+
+TEST_OBJS = $(TEST_SRCS:.cpp=.o)
+
+CXXFLAGS = -g -Wall
+TESTCXXFLAGS = -I${HOME}/include
+
+all : $(BIN) $(TEST_BIN)
+
+%.o: %.cpp $(DEPS)
+ $(CXX) -c -o $@ $< $(CXXFLAGS) $(TESTCXXFLAGS)
+
+$(BIN) : $(OBJS)
+ $(CXX) -o $@ $^ $(CXXFLAGS)
+
+$(TEST_BIN) : $(TEST_OBJS)
+ $(CXX) -o $@ $^ $(TESTCXXFLAGS)
+ ./$(TEST_BIN)
+
+clean :
+ rm -rf $(OBJS) $(BIN) $(TEST_OBJS) $(TEST_BIN)
+
diff --git a/codeseries.zip b/codeseries.zip
new file mode 100644
index 0000000000000000000000000000000000000000..22c3d6ad1ef4fa8dff1099cb9c326a0fa323ba0e
GIT binary patch
literal 4638
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
Y-UO$RXYeIHHf}JW6>s9ol*j-64|tDwHUIzs
literal 0
HcmV?d00001
diff --git a/combo.cpp b/combo.cpp
new file mode 100644
index 0000000..5f7cf69
--- /dev/null
+++ b/combo.cpp
@@ -0,0 +1,57 @@
+//Copyright (c) 2013 Bradley M. Small
+#include "combo.h"
+
+Combo::Combo(Cut cut, int Count) : count(Count) , comb(Count,cut), rolled(false){}
+
+Combo::Combo(const Combo& other) : count(other.count), comb(other.comb), rolled(false){}
+
+Combo& Combo::operator++() {
+ int rollCount( 0 );
+ for (std::vector<Cut>::reverse_iterator x = comb.rbegin(); x < comb.rend(); ++x){
+ ++(*x);
+ if(!(*x).isRolled()) break;
+ ++rollCount;
+ }
+ if (rollCount == count)
+ rolled = true;
+ return *this;
+}
+
+Combo& Combo::operator--() {
+ int rollCount( 0 );
+ for (std::vector<Cut>::reverse_iterator x = comb.rbegin(); x < comb.rend(); ++x){
+ --(*x);
+ if(!(*x).isRolled()) break;
+ ++rollCount;
+ }
+ if (rollCount == count)
+ rolled = true;
+
+ return *this;
+}
+
+Combo Combo::operator++(int) {
+ Combo c(*this);
+ ++(*this);
+ return c;
+}
+
+Combo Combo::operator--(int) {
+ Combo c(*this);
+ --(*this);
+ return c;
+}
+
+bool Combo::isRolled() {
+ return (rolled)?rolled=false, true:false;
+}
+
+std::ostream& operator<<(std::ostream& stream, const Combo &c) {
+
+ for (std::vector<Cut>::const_iterator x = c.comb.begin(); x < c.comb.end(); ++x){
+ stream << (*x);
+ }
+ stream << std::endl;
+ return stream;
+}
+
diff --git a/combo.h b/combo.h
new file mode 100644
index 0000000..e4112b6
--- /dev/null
+++ b/combo.h
@@ -0,0 +1,23 @@
+//Copyright (c) 2013 Bradley M. Small
+#ifndef _COMBO_H_
+#define _COMBO_H_
+#include <vector>
+
+#include "cut.h"
+class Combo {
+public:
+ Combo(Cut cut = Cut('A', 'A', 'E'), int Count = 6);
+ Combo(const Combo & other);
+ Combo& operator++();
+ Combo& operator--();
+ Combo operator++(int);
+ Combo operator--(int);
+ friend class Tests;
+ friend std::ostream& operator<<(std::ostream& stream, const Combo& c);
+ bool isRolled();
+private:
+ int count;
+ std::vector<Cut> comb;
+ bool rolled;
+};
+#endif
diff --git a/cut.cpp b/cut.cpp
new file mode 100644
index 0000000..465ce7a
--- /dev/null
+++ b/cut.cpp
@@ -0,0 +1,56 @@
+//Copyright (c) 2013 Bradley M. Small
+#include <iostream>
+#include "cut.h"
+
+Cut::Cut(char Val, char Low, char High) : low(Low), high(High), val(Val), rolled(false) { }
+
+Cut::Cut(const Cut& other) : low(other.low), high(other.high), val(other.val), rolled(false) { }
+
+Cut& Cut::operator++() {
+ if(++val > high) {
+ val = low;
+ rolled=true;
+ }
+ return *this;
+}
+
+Cut& Cut::operator--() {
+ if(--val < low) {
+ val = high;
+ rolled=true;
+ }
+ return *this;
+}
+
+Cut Cut::operator++(int) {
+ Cut result(*this);
+ ++(*this);
+ return result;
+}
+
+Cut Cut::operator--(int) {
+ Cut result(*this);
+ --(*this);
+ return result;
+}
+
+bool Cut::isRolled() {
+ return (rolled)?rolled=false, true:false;
+}
+
+bool Cut::operator==(const Cut & rhs) const {
+ return (this->val == rhs.val);
+}
+
+bool operator<(const Cut & lhs, const Cut & rhs) {
+ return (lhs.val < rhs.val);
+}
+
+std::ostream& operator<<(std::ostream& stream, const Cut& cut) {
+ stream << cut.val;
+ return stream;
+}
+
+int operator-(const Cut & lhs, const Cut & rhs) {
+ return (lhs.val - rhs.val);
+}
diff --git a/cut.h b/cut.h
new file mode 100644
index 0000000..bbe54e0
--- /dev/null
+++ b/cut.h
@@ -0,0 +1,27 @@
+//Copyright (c) 2013 Bradley M. Small
+#ifndef _CUT_H_
+#define _CUT_H_
+#include<iostream>
+class Cut {
+public:
+ Cut(char Val='A', char Low='A', char High='Z');
+ Cut(const Cut& other);
+ bool isRolled();
+ Cut& operator++();
+ Cut& operator--();
+ Cut operator++(int);
+ Cut operator--(int);
+ bool operator==(const Cut & rhs) const ;
+ friend bool operator<(const Cut & lhs, const Cut & rhs);
+ friend int operator-(const Cut&, const Cut& );
+ friend std::ostream& operator<<(std::ostream& stream, const Cut& cut);
+ char GetHigh() const {return high;};
+ char GetLow() const {return low; };
+ char GetVal() const {return val; };
+private:
+ char low;
+ char high;
+ char val;
+ bool rolled;
+};
+#endif
diff --git a/main.cpp b/main.cpp
new file mode 100644
index 0000000..32ee1a0
--- /dev/null
+++ b/main.cpp
@@ -0,0 +1,58 @@
+//Copyright (c) 2013 Bradley M. Small
+#include <iostream>
+#include "cut.h"
+#include "combo.h"
+#include "tests.h"
+#include <algorithm>
+#include <cmath>
+
+const bool debug ( false );
+
+bool isValid(Combo combo) {
+ // apply rules here
+ bool retVal (true);
+ Tests t;
+ const size_t mostContiguous ( 3 );
+ const size_t mostPresent ( 4 );
+ const size_t maxAdjacent ( 2 );
+
+ if(t.MostContiguous(combo) > mostContiguous) {
+ if(debug) std::cout << "\tMaxContig:" << combo;
+ retVal = false;
+ }
+ if(t.MostPresent(combo) > mostPresent) {
+ if(debug) std::cout << "\tMaxPresent:" << combo;
+ retVal = false;
+ }
+ if(t.MaxAdjacent(combo) > maxAdjacent) {
+ if(debug) std::cout << "\tMaxAdjacent:" << combo;
+ retVal = false;
+ }
+
+ return retVal;
+}
+
+int main( void ) {
+ Cut cut('A', 'A', 'E');
+ Combo combo(cut, 6);
+
+ std::vector<Combo> codeSeries;
+
+ for(;!combo.isRolled();){
+ if( isValid(combo) )
+ codeSeries.push_back(combo);
+ ++combo;
+ }
+
+ std::random_shuffle(codeSeries.begin(), codeSeries.end());
+
+ int width = ceil(log10(codeSeries.size()));
+ int num(1);
+
+ for (std::vector<Combo>::iterator x = codeSeries.begin(); x < codeSeries.end(); ++x) {
+ std::cout.width(width);
+ std::cout.fill('0');
+ std::cout << num++ << " : " << *x;
+ }
+ return 0;
+}
diff --git a/tests.cpp b/tests.cpp
new file mode 100644
index 0000000..8aa7266
--- /dev/null
+++ b/tests.cpp
@@ -0,0 +1,93 @@
+//Copyright (c) 2013 Bradley M. Small
+#include "tests.h"
+#include "combo.h"
+#include "cut.h"
+#include <vector>
+#include <cstdlib>
+#include <map>
+
+size_t Tests::MostContiguous( const Combo & combo ){
+ size_t High (1), CurrentCount( 1 );
+
+ for (std::vector<Cut>::const_iterator x = combo.comb.begin() + 1; x < combo.comb.end(); ++x) {
+ if(*x == *(x-1)) {
+ ++CurrentCount;
+ if(CurrentCount > High)
+ High = CurrentCount;
+ } else {
+ CurrentCount = 1;
+ }
+ }
+ return (High);
+}
+
+size_t Tests::LeastContiguous ( const Combo & combo ){
+ size_t Low(combo.comb.size()), CurrentCount(1);
+ for (std::vector<Cut>::const_iterator x = combo.comb.begin() + 1; x < combo.comb.end(); ++x) {
+ if(*x == *(x-1)) {
+ ++CurrentCount;
+ } else {
+ if(CurrentCount < Low)
+ Low = CurrentCount;
+ CurrentCount = 1;
+ }
+ }
+ return (Low);
+}
+
+size_t Tests::MostPresent ( const Combo & combo ){
+ std::map<Cut,size_t> cutMap;
+ size_t Max ( 1 );
+ for (std::vector<Cut>::const_iterator x = combo.comb.begin(); x < combo.comb.end(); ++x) {
+ if(cutMap.find(*x) == cutMap.end()) {
+ cutMap[*x] = 1;
+ } else {
+ ++cutMap[*x];
+ }
+ }
+ for(std::map<Cut, size_t>::const_iterator x = cutMap.begin(); x != cutMap.end(); ++x) {
+ if(x->second > Max)
+ Max = x->second;
+ }
+ return (Max);
+}
+
+size_t Tests::LeastPresent ( const Combo & combo ){
+ std::map<Cut,size_t> cutMap;
+ size_t Min ( combo.comb.size() );
+ for (std::vector<Cut>::const_iterator x = combo.comb.begin(); x < combo.comb.end(); ++x) {
+ if(cutMap.find(*x) == cutMap.end()) {
+ cutMap[*x] = 1;
+ } else {
+ ++cutMap[*x];
+ }
+ }
+ for(std::map<Cut, size_t>::const_iterator x = cutMap.begin(); x != cutMap.end();++x) {
+ if(x->second < Min)
+ Min = x->second;
+ }
+ return(Min);
+}
+
+size_t Tests::MaxAdjacent ( const Combo & combo ){
+ size_t Max ( 0 );
+ size_t CurrentDiff ( 0 );
+ for (std::vector<Cut>::const_iterator x = combo.comb.begin() + 1; x < combo.comb.end(); ++x) {
+
+ CurrentDiff = abs(*x - *(x-1));
+ if (CurrentDiff > Max)
+ Max = CurrentDiff;
+ }
+ return (Max);
+}
+
+size_t Tests::MinAdjacent ( const Combo & combo ){
+ size_t Min ( 25 );
+ size_t CurrentDiff ( 0 );
+ for (std::vector<Cut>::const_iterator x = combo.comb.begin() + 1; x < combo.comb.end(); ++x) {
+ CurrentDiff = abs(*x - *(x-1));
+ if (CurrentDiff < Min)
+ Min = CurrentDiff;
+ }
+ return (Min);
+}
diff --git a/tests.h b/tests.h
new file mode 100644
index 0000000..196858b
--- /dev/null
+++ b/tests.h
@@ -0,0 +1,19 @@
+//Copyright (c) 2013 Bradley M. Small
+#ifndef _TESTS_H_
+#define _TESTS_H_
+
+#include "combo.h"
+#include "cut.h"
+
+class Tests {
+public:
+ size_t MostContiguous ( const Combo & combo );
+ size_t LeastContiguous ( const Combo & combo );
+ size_t MostPresent ( const Combo & combo );
+ size_t LeastPresent ( const Combo & combo );
+ size_t MaxAdjacent ( const Combo & combo );
+ size_t MinAdjacent ( const Combo & combo );
+private:
+};
+
+#endif
diff --git a/unit_test.cpp b/unit_test.cpp
new file mode 100644
index 0000000..aac51c3
--- /dev/null
+++ b/unit_test.cpp
@@ -0,0 +1,52 @@
+#include "tests.h"
+#include "combo.h"
+#include "cut.h"
+#define BOOST_TEST_MODULE CodeSeriesTests
+#include <boost/test/included/unit_test.hpp>
+
+BOOST_AUTO_TEST_SUITE( test_class_cut )
+BOOST_AUTO_TEST_CASE( test_cut_ctor0 )
+{
+ Cut a;
+
+ BOOST_CHECK_EQUAL( a.GetHigh(), 'Z' );
+ BOOST_CHECK_EQUAL( a.GetLow() , 'A' );
+ BOOST_CHECK_EQUAL( a.GetVal() , 'A' );
+}
+BOOST_AUTO_TEST_CASE( test_cut_ctor1 )
+{
+ Cut b('Q', 'P', 'R');
+
+ BOOST_CHECK_EQUAL( b.GetHigh(), 'R' );
+ BOOST_CHECK_EQUAL( b.GetLow() , 'P' );
+ BOOST_CHECK_EQUAL( b.GetVal() , 'Q' );
+}
+BOOST_AUTO_TEST_CASE( test_cut_ctor2 )
+{
+ Cut c('J');
+
+ BOOST_CHECK_EQUAL( c.GetHigh(), 'Z' );
+ BOOST_CHECK_EQUAL( c.GetLow() , 'A' );
+ BOOST_CHECK_EQUAL( c.GetVal() , 'J' );
+
+}
+BOOST_AUTO_TEST_CASE( test_cut_plusminus )
+{
+ Cut d;
+
+ BOOST_CHECK_EQUAL( d.GetVal() , 'A' );
+ d++;
+ BOOST_CHECK_EQUAL( d.GetVal() , 'B' );
+ ++d;
+ BOOST_CHECK_EQUAL( d.GetVal() , 'C' );
+ --d;
+ BOOST_CHECK_EQUAL( d.GetVal() , 'B' );
+ d--;
+ BOOST_CHECK_EQUAL( d.GetVal() , 'A' );
+ d--;
+ BOOST_CHECK_EQUAL( d.GetVal() , 'Z' );
+ d++;
+ BOOST_CHECK_EQUAL( d.GetVal() , 'A' );
+
+}
+BOOST_AUTO_TEST_SUITE_END()
--
GitLab