Barclays Challenge 500

keshavnandan · keshavnandan · commit 21e3f888a315 · 2015-02-04T14:37:40.000+05:30
diff --git a/FloatingPoint.cpp b/FloatingPoint.cpp
@@ -0,0 +1,55 @@
+#include <iostream>
+#include <sstream>
+#include <vector>
+#include <algorithm>
+#include <set>
+#include <map>
+#include <queue>
+#include <cstring>
+#include <climits>
+#include <cstdio>
+#include <cmath>
+using namespace std;
+typedef pair<int,int> pi;
+typedef set<int> si;
+typedef vector<int> vi;
+typedef vector<vi> vvi;
+typedef vector<string> vs;
+
+class FloatingPoint{ 
+        public: 
+        int representations(int number, int mantissa, int exponent) { 
+           int first = 0, last = log2(number);
+           while(!( (1<<first) & number )) first++;
+           cout<<first<<" "<<last<<endl;
+           int total = 0;
+           while(first >= 0){
+            if((last - first + 1) <= mantissa && first < (1<<exponent)) total++;
+            first--;
+           }
+           return total;
+        } 
+        
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arg0 = 24; int Arg1 = 4; int Arg2 = 2; int Arg3 = 3; verify_case(0, Arg3, representations(Arg0, Arg1, Arg2)); }
+	void test_case_1() { int Arg0 = 1; int Arg1 = 3; int Arg2 = 3; int Arg3 = 1; verify_case(1, Arg3, representations(Arg0, Arg1, Arg2)); }
+	void test_case_2() { int Arg0 = 8; int Arg1 = 3; int Arg2 = 3; int Arg3 = 3; verify_case(2, Arg3, representations(Arg0, Arg1, Arg2)); }
+	void test_case_3() { int Arg0 = 16; int Arg1 = 5; int Arg2 = 2; int Arg3 = 4; verify_case(3, Arg3, representations(Arg0, Arg1, Arg2)); }
+	void test_case_4() { int Arg0 = 17408; int Arg1 = 10; int Arg2 = 10; int Arg3 = 6; verify_case(4, Arg3, representations(Arg0, Arg1, Arg2)); }
+
+// END CUT HERE
+ 
+}; 
+
+// BEGIN CUT HERE 
+int main(){
+
+        FloatingPoint ___test; 
+        ___test.run_test(-1); 
+} 
+// END CUT HERE     
diff --git a/FloatingPoint.html b/FloatingPoint.html
@@ -0,0 +1,7 @@
+<html><body bgcolor="#000000" text="#ffffff"><table><tr><td colspan="2"><h3>Problem Statement</h3></td></tr><tr><td>&#160;&#160;&#160;&#160;</td><td><p>
+A <i>floating point</i> representation of a number in <i>base</i> <tt>b</tt> is written as <tt>M * b<sup>E</sup></tt>, where M is called the <i>mantissa</i> and E is the <i>exponent</i>. Depending on the allowed values for <tt>M</tt> and <tt>E</tt>, a number may have multiple possible representations.  In this problem, we will work with base 2, and we will limit M and E to be unsigned integers, each with a fixed number of bits.  You must determine the number of possible representations a given number has in such a system.
+</p>
+<p>
+For example, a 4-bit mantissa has a range of 0 to 15, inclusive, and a 2-bit exponent has a range of 0 to 3, inclusive.  Using this system, the number 24 can be represented as: 12*2<sup>1</sup>, 6*2<sup>2</sup>, and 3*2<sup>3</sup>.  Note that every time the mantissa is doubled or halved, the exponent is decremented or incremented by 1, respectively.  Given an int <b>number</b>, and the sizes in bits of the <b>mantissa</b> and <b>exponent</b>, return the number of floating point representations that are possible for that <b>number</b>.
+</p>
+</td></tr><tr><td colspan="2"><h3>Definition</h3></td></tr><tr><td>&#160;&#160;&#160;&#160;</td><td><table><tr><td>Class:</td><td>FloatingPoint</td></tr><tr><td>Method:</td><td>representations</td></tr><tr><td>Parameters:</td><td>int, int, int</td></tr><tr><td>Returns:</td><td>int</td></tr><tr><td>Method signature:</td><td>int representations(int number, int mantissa, int exponent)</td></tr><tr><td colspan="2">(be sure your method is public)</td></tr></table></td></tr><tr><td colspan="2"><h3>Limits</h3></td></tr><tr><td>&#160;&#160;&#160;&#160;</td><td><table><tr><td>Time limit (s):</td><td>2.000</td></tr><tr><td>Memory limit (MB):</td><td>64</td></tr></table></td></tr><tr><td colspan="2"><h3>Constraints</h3></td></tr><tr><td align="center" valign="top">-</td><td><b>number</b> will be between 1 and 1000000000 (10<sup>9</sup>), inclusive.</td></tr><tr><td align="center" valign="top">-</td><td><b>mantissa</b> will be between 1 and 20, inclusive.</td></tr><tr><td align="center" valign="top">-</td><td><b>exponent</b> will be between 1 and 20, inclusive.</td></tr><tr><td colspan="2"><h3>Examples</h3></td></tr><tr><td align="center" nowrap="true">0)</td><td></td></tr><tr><td>&#160;&#160;&#160;&#160;</td><td><table><tr><td><table><tr><td><pre>24</pre></td></tr><tr><td><pre>4</pre></td></tr><tr><td><pre>2</pre></td></tr></table></td></tr><tr><td><pre>Returns: 3</pre></td></tr><tr><td><table><tr><td colspan="2">Example from the problem statement.</td></tr></table></td></tr></table></td></tr><tr><td align="center" nowrap="true">1)</td><td></td></tr><tr><td>&#160;&#160;&#160;&#160;</td><td><table><tr><td><table><tr><td><pre>1</pre></td></tr><tr><td><pre>3</pre></td></tr><tr><td><pre>3</pre></td></tr></table></td></tr><tr><td><pre>Returns: 1</pre></td></tr><tr><td><table><tr><td colspan="2">The number 1 can be represented in only one way (regardless of the mantissa and exponent sizes).</td></tr></table></td></tr></table></td></tr><tr><td align="center" nowrap="true">2)</td><td></td></tr><tr><td>&#160;&#160;&#160;&#160;</td><td><table><tr><td><table><tr><td><pre>8</pre></td></tr><tr><td><pre>3</pre></td></tr><tr><td><pre>3</pre></td></tr></table></td></tr><tr><td><pre>Returns: 3</pre></td></tr><tr><td><table><tr><td colspan="2">To represent the number 8 we can choose (ordered by exponent) from: 8*2<sup>0</sup>, 4*2<sup>1</sup>, 2*2<sup>2</sup>, 1*2<sup>3</sup>. The exponent has the range for larger numbers, but the smallest mantissa is used in the last case in this list.</td></tr></table></td></tr></table></td></tr><tr><td align="center" nowrap="true">3)</td><td></td></tr><tr><td>&#160;&#160;&#160;&#160;</td><td><table><tr><td><table><tr><td><pre>16</pre></td></tr><tr><td><pre>5</pre></td></tr><tr><td><pre>2</pre></td></tr></table></td></tr><tr><td><pre>Returns: 4</pre></td></tr><tr><td><table><tr><td colspan="2">To represent the number 16 we can choose (ordered by exponent) from: 16*2<sup>0</sup>, 8*2<sup>1</sup>, 4*2<sup>2</sup>, and 2*2<sup>3</sup>. Here the next possibility (1*2<sup>4</sup>) would require an exponent that cannot be represented with 3 bits.</td></tr></table></td></tr></table></td></tr><tr><td align="center" nowrap="true">4)</td><td></td></tr><tr><td>&#160;&#160;&#160;&#160;</td><td><table><tr><td><table><tr><td><pre>17408</pre></td></tr><tr><td><pre>10</pre></td></tr><tr><td><pre>10</pre></td></tr></table></td></tr><tr><td><pre>Returns: 6</pre></td></tr><tr><td><table><tr><td colspan="2">Note that 17408 = 17*2<sup>10</sup>. Thus the number 17 (or 1001 in binary notation) can be shifted to fit in 6 positions within the 10 mantissa bits (using leading or trailing zeros): from 17*2<sup>10</sup> to 544*2<sup>5</sup>. Any exponent less than 5 would overflow the mantissa.</td></tr></table></td></tr></table></td></tr></table><p>This problem statement is the exclusive and proprietary property of TopCoder, Inc.  Any unauthorized use or reproduction of this information without the prior written consent of TopCoder, Inc. is strictly prohibited.  (c)2003, TopCoder, Inc.  All rights reserved.  </p></body></html>
