सी ++ मैराथन कार्य

• भूल गए कि कैसे गुणा करना है। मदद!
  गुणा ऑपरेशन का उपयोग किए बिना एक संख्या को 7 से गुणा करें।
  
• एक में दो।
  किसी जानकार ने लिफ्ट में लगे बटन को स्वैप किया। पहली मंजिल के बजाय दूसरी मंजिल रखो, और दूसरी के बजाय पहली मंजिल। ईमानदारी से, मैं बटन लेने के लिए बहुत आलसी हूं। मैं लिफ्ट को दोबारा बनाना चाहता हूं। लेकिन मैं कार्यक्रम के लिए बहुत आलसी हूं। सभी आपसे आशा करते हैं। कृपया एक स्विच फ़ंक्शन लिखें जो 1 इनपुट 2 और 2 देता है, यदि इनपुट 1।
  

ट्रेनिंग

चलो चलते हैं

समय की संख्या:

भूल गए कि कैसे गुणा करना है। मदद! गुणा ऑपरेशन का उपयोग किए बिना एक संख्या को 7 से गुणा करें।

• एक फ़ंक्शन जो एक संख्या को 7 से गुणा करने के लिए मिलता है एक तर्क के रूप में 7 लगातार परिवर्धन करता है, जिसके बाद यह परिणाम (रनटाइम) लौटाता है:
  

  //      typedef unsigned long long TCurrentCalculateType; inline TCurrentCalculateType mulby7(TCurrentCalculateType value) { return value + value + value + value + value + value + value; } //  ,  assert()   // #include <assert.h> #ifdef DEGUB assert(mulby7(1) == 7); assert(mulby7(7) == 49); #endif //DEBUG 

  
  

• एक पुनरावृत्ति फ़ंक्शन जो एक तर्क के रूप में एन द्वारा गुणा किया जाता है, एक लूप में एन लगातार परिवर्धन करता है, और फिर परिणाम (रनटाइम) लौटाता है:
  

   //    // typedef unsigned long long TCurrentCalculateType; inline TCurrentCalculateType mulbyN(unsigned long long times, TCurrentCalculateType value) { TCurrentCalculateType result = 0; for(unsigned long long i = 0; i < times; ++i) result += value; return result; } //  ,  assert()   // #include <assert.h> #ifdef DEGUB assert(mulbyN(7, 1) == mulbyN(1, 7)); assert(mulbyN(7, 7) == 49); #endif //DEBUG 

  
  
• एक मानकीकृत वर्ग जो एक तर्क के रूप में एन से गुणा करने के लिए एक संख्या प्राप्त करता है, एन अनुक्रमिक परिवर्धन करता है, पुनरावर्ती रूप से तात्कालिक रूप से त्वरित करता है, जिसके बाद परिणाम कक्षा के स्थिर कास्ट सदस्य (संकलन) में उपलब्ध होता है:
  

   //    // typedef unsigned long long TCurrentCalculateType; // : , , : , ... //  N + 1   ( ) template <typename T, T value, int step> struct mulStep { static const T partSumm = value + mulStep<T, value, step - 1>::partSumm; }; //  ,   template <typename T, T value> struct mulStep<T, value, 0> { static const T partSumm = 0; }; template <unsigned long long times, TCurrentCalculateType value> struct mulbyNct { static const TCurrentCalculateType result = mulStep<TCurrentCalculateType, value, times>::partSumm; }; static_assert(mulbyNct<7, 7>::result == 49, "Imposible!"); static_assert(mulbyNct<10, 10>::result == 100, "Imposible!"); 

 template <int times, typename T> inline T mulbyNct(T value) { return mulStep<T, value, times>::partSumm; } //  ... // std::cout << mulbyNct<7>(calcMeDigit) << std::endl; //  .   :( 

 //    // typedef unsigned long long TCurrentCalculateType; inline TCurrentCalculateType mulbyNlittleFast(unsigned long long times, TCurrentCalculateType value) { TCurrentCalculateType result = value; //   for(unsigned long long i = 1; i < times; ++i) //   result += value; return result; } //     //     ,   #undef mulbyN #define mulbyN mulbyNlittleFast //  ,  assert()   // #include <assert.h> #ifdef DEGUB assert(mulbyN(7, 1) == mulbyN(1, 7)); assert(mulbyN(7, 7) == 49); #endif //DEBUG 

• ओह यह चौथा विकल्प:
  

   //    // typedef unsigned long long TCurrentCalculateType; inline TCurrentCalculateType mulbyNSTL(unsigned long long times, TCurrentCalculateType value) { TCurrentCalculateType result = value; std::binder1st<std::plus<TCurrentCalculateType> > plus1st(std::plus<TCurrentCalculateType>(), value); for(unsigned long long i = 1; i < times; ++i) result = plus1st(result); return result; } //  ,  assert()   // #include <assert.h> #ifdef DEGUB assert(mulbyNSTL(7, 1) == mulbyNSTL(1, 7)); assert(mulbyNSTL(7, 7) == 49); #endif //DEBUG 

लड़ने की तैयारी करो

 #include <stdio.h> #include <string> #include <sys/time.h> #include <sys/timeb.h> class StackPrinter { public: explicit StackPrinter(const char* msg) : msMsg(msg) { fprintf(stdout, "%s: --begin\n", msMsg.c_str()); mfStartTime = getTime(); } ~StackPrinter() { double fEndTime = getTime(); fprintf(stdout, "%s: --end (duration: %.10f sec)\n", msMsg.c_str(), (fEndTime-mfStartTime)); } void printTime(int line) const { double fEndTime = getTime(); fprintf(stdout, "%s: --(%d) (duration: %.10f sec)\n", msMsg.c_str(), line, (fEndTime-mfStartTime)); } private: double getTime() const { timeval tv; gettimeofday(&tv, NULL); return tv.tv_sec + tv.tv_usec / 1000000.0; } ::std::string msMsg; double mfStartTime; }; // Use case // //{ // StackPrinter("Time to sleep") sp; // sleep(5000); //} 

 class StackPrinterTiny { public: explicit StackPrinterTiny(const char* msg) { mfStartTime = getTime(); } ~StackPrinterTiny() { double fEndTime = getTime(); fprintf(stdout, "%g\n", (fEndTime-mfStartTime)); } void printTime(int line) const { double fEndTime = getTime(); fprintf(stdout, "(%d) %g\n", line, (fEndTime-mfStartTime)); } private: double getTime() const { timeval tv; gettimeofday(&tv, NULL); return tv.tv_sec + tv.tv_usec / 1000000.0; } double mfStartTime; }; #ifdef OutToAnalyze typedef StackPrinterTiny usedStackPrinter; #else typedef StackPrinter usedStackPrinter; #endif // Use case // //{ // usedStackPrinter("Time to sleep") sp; // sleep(5000); //} 

फिनिश लाइन पर

 #include <iostream> #include <functional> #include <stdio.h> #include <string> #include <sys/time.h> #include <sys/timeb.h> #include <climits> typedef unsigned long long TCurrentCalculateType; // Closured: result, fiMax // loop, loooop, loooooooop #define LOOP_LOOP(what) \ for(unsigned long long fi = 0; fi < fiMax; ++fi) \ for(unsigned long long fi2 = 0; fi2 < fiMax; ++fi2) \ for(unsigned long long fi3 = 0; fi3 < fiMax; ++fi3) \ result = what int main() { //     mulbyNct<> const TCurrentCalculateType calcMeDigit = 9000000; const unsigned long long fiMax = ULLONG_MAX; #ifndef OutToAnalyze std::cout << "Calculate: " << calcMeDigit << " with fiMax = " << fiMax << std::endl; #endif currentCalculateType result = 0; #ifdef CALCULATE_IN_COMPILE_TIME std::cout << "compile time " << calcMeDigit << " * " << calcMeDigit << " = " << mulbyNct<calcMeDigit, calcMeDigit>::result << std::endl; #endif { usedStackPrinter sp("1"); // on image - mulby7 LOOP_LOOP(mulby7(calcMeDigit)); #ifndef OutToAnalyze std::cout << "by x7 = " << result << std::endl; #else std::cout << "=" << result << std::endl; #endif } { usedStackPrinter sp("2"); // on image - mulbyN LOOP_LOOP(mulbyN(calcMeDigit, calcMeDigit)); #ifndef OutToAnalyze std::cout << "x*x where x is " << calcMeDigit << " = " << result << std::endl; #else std::cout << "=" << result << std::endl; #endif } { usedStackPrinter sp("3"); // on image - mulbyNSTL LOOP_LOOP(mulbyNSTL(calcMeDigit, calcMeDigit)); #ifndef OutToAnalyze std::cout << "STL x*x where x is " << calcMeDigit << " = " << result << std::endl; #else std::cout << "=" << result << std::endl; #endif } return 0; } // Compile with // // clear && g++ main.1.cpp -O3 -std=c++0x -o main.1 // PS      -Ofast.    -  . 

हमने सोचा, हमने सोचा कि हमारे कोर थक गए थे

पहले मैं दूसरा हूँ

टास्क नंबर दो:

एक में दो। किसी जानकार ने लिफ्ट में लगे बटन को स्वैप किया। पहली मंजिल के बजाय दूसरी मंजिल रखो और दूसरी के बजाय पहली मंजिल। ईमानदारी से, मैं बटन लेने के लिए बहुत आलसी हूं। मैं लिफ्ट को दोबारा बनाना चाहता हूं। लेकिन मैं कार्यक्रम के लिए बहुत आलसी हूं। सभी आपसे आशा करते हैं। कृपया एक स्विच फ़ंक्शन लिखें जो 1 इनपुट 2 और 2 देता है, यदि इनपुट 1।

• फ़ंक्शन, जो एक तर्क के रूप में मंजिल नंबर प्राप्त करता है, बिटवाइज़ जोड़ मोडुलो दो करता है और परिणाम देता है:
  

   int worker1(unsigned int n) { return (n xor 3); } //  ,  assert()   // #include <assert.h> #ifdef DEGUB assert(worker1(2) == 1); assert(worker1(1) == 2); #endif //DEBUG 

  
  

 int worker2(unsigned int n) { return (n & 1) + 1; } //  ,  assert()   // #include <assert.h> #ifdef DEGUB assert(worker2(2) == 1); assert(worker2(1) == 2); #endif //DEBUG 

 int worker3(unsigned int n) { return 3 - n; } //  ,  assert()   // #include <assert.h> #ifdef DEGUB assert(worker3(2) == 1); assert(worker3(1) == 2); #endif //DEBUG 

 // Like binder1st // require #include <numeric>, #include <random> template <class Operation, class TRandomEngine> class binderRandom: public std::unary_function <void, typename Operation::result_type> { protected: Operation op; TRandomEngine& y; public: binderRandom ( const Operation& x, TRandomEngine& y) : op (x), y (y) {} typename Operation::result_type operator()() { return op(y); } }; 

 #include <iostream> #include <functional> #include <stdio.h> #include <string> #include <sys/time.h> #include <sys/timeb.h> #include <climits> #include <vector> #include <algorithm> #include <numeric> #include <random> #include <iterator> int main() { static std::mt19937 _randomNumbersEngine; std::vector<unsigned int> _vectorNumbers(50000000); //    ? std::uniform_int<unsigned int> uiRandomNumber(1, 2); std::generate(_vectorNumbers.begin(), _vectorNumbers.end(), binderRandom<std::uniform_int<unsigned int>, std::mt19937>(uiRandomNumber, _randomNumbersEngine)); //    - //    // { usedStackPrinter sp("1"); std::transform(_vectorNumbers.begin(), _vectorNumbers.end(), _vectorNumbers.begin(), worker1); } { usedStackPrinter sp("2"); std::transform(_vectorNumbers.begin(), _vectorNumbers.end(), _vectorNumbers.begin(), worker2); } { usedStackPrinter sp("3"); std::transform(_vectorNumbers.begin(), _vectorNumbers.end(), _vectorNumbers.begin(), worker3); } return 0; } 

 inline TCurrentCalculateType mulby7fast(TCurrentCalculateType value) { return (value << 3) - value; } 

• अगर किसी को पता है कि किस कंपाइलर में यह इकट्ठा होगा:
  

   inline float mulby7fast(float value) { return (value << 3) - value; } 

  कृपया लिखो शर्म मत करो।
• हां, मुझे नहीं पता था (और मैं ऐसा कुछ भी नहीं कर सकता हूं):
  

  मनमाने ढंग से संख्या का गुणा उस स्थिति में बदलाव के योग के रूप में किया जाता है जहां गुणक की एकता में होती है

  Google का उपयोग करना सीखने के लिए - पता लगाने के लिए नहीं, बल्कि झांकने के लिए।
• शांत विपक्ष - बहुत उत्साहजनक

निष्कर्ष

• यह पता चलता है कि सभी प्रकार के ऑटो पूर्ण के साथ आईडीई के बिना लेखन (जैसे कि पूरे टमाटर से विज़ुअल असिस्ट एक्स) इतना घातक नहीं है (जाहिर है 200 से अधिक लाइनों और सरल तर्क)। हां, बहुत सी चीजें गायब हैं: चतुर संरेखण, जोड़ी कोष्ठक और उद्धरण चिह्न, लेकिन इसमें कुछ है ... कुछ जो मुझे बताता है: एक सही और सुविधाजनक आईडीई शांत है!
• संस्करण 4.4.5 gcc और इसलिए मैंने लैम्ब्डा का उपयोग नहीं किया - लेकिन "कार्यकर्ताएन" के मामले में यह बहुत अच्छा लगेगा
  

   std::transform(_vectorNumbers.begin(), _vectorNumbers.end(), _vectorNumbers.begin(), [](int n) { return n xor 3; } );