সি ++, আপনার কাছের কম্পিউটারে সমস্ত স্মৃতি বিস্ফোরিত হচ্ছে
সংক্ষিপ্ততম স্ট্রিং তৈরি করে যেখানে গণনাটি কোথাও স্বাক্ষরিত 32-বিট পূর্ণসংখ্যার উপচে পড়ার কারণ নয় (সুতরাং সমস্ত মধ্যবর্তী ফলাফল সীমার মধ্যে রয়েছে) [-2147483648, 2147483647]
আমার সিস্টেমে এটি 4834321.8G মেমরি ব্যবহার করার সময় 30 সেকেন্ড পর্যন্ত এবং সমস্ত সংখ্যার জন্য একটি সমাধান উত্পন্ন করে। এমনকি উচ্চতর নম্বরগুলি মেমরির ব্যবহারটি দ্রুত বিস্ফোরিত করবে। আমি আমার সিস্টেমে সর্বোচ্চ সংখ্যাটি পরিচালনা করতে পারি 5113906। গণনাটি প্রায় 9 মিনিট এবং 24 জিবি লাগে takes এটি শেষ হলে এটি অভ্যন্তরীণভাবে সমাধানের সমাধান করে398499338 মানগুলির , সমস্ত 32 বিট পূর্ণসংখ্যার প্রায় 9% (ধনাত্মক এবং নেতিবাচক)
একটি সি ++ 11 সংকলক প্রয়োজন। লিনাক্স এর সাথে কম্পাইল করে:
g++ -Wall -O3 -march=native -std=gnu++11 -s befour.cpp -o befour
-DINT64মধ্যবর্তী ফলাফলের জন্য 32-বিটের পরিবর্তে 64-বিট পূর্ণসংখ্যার পরিসর ব্যবহার করার বিকল্প হিসাবে যুক্ত করুন (এটি প্রায় 50% বেশি সময় এবং মেমরি ব্যবহার করবে)। এটি একটি বিল্টিন 128 বিট প্রকারের প্রয়োজন। আপনার জিসিসির ধরণের পরিবর্তন করতে হবে __int128। কমপক্ষে সীমার কোনও ফলাফল নেই[1..483432]বৃহত্তর মধ্যবর্তী ফলাফলের অনুমতি দিয়ে পরিবর্তনের ।
যোগ -DOVERFLOWওভারফ্লো পরীক্ষা করার জন্য বড় সংখ্যার ধরণের ব্যবহার না করার বিকল্প হিসাবে যুক্ত । এটির ওভারফ্লো এবং মান মোড়ানোর অনুমতি দেয় has
যদি আপনার সিস্টেমে tcmalloc ( https://github.com/gperftools/gperftools ) থাকে তবে আপনি সেই প্রোগ্রামটির সাথে লিঙ্ক করতে পারেন যার ফলস্বরূপ একটি প্রোগ্রাম যা সাধারণত কিছুটা দ্রুত এবং সামান্য কম স্মৃতি ব্যবহার করে। কিছু ইউনিক্স সিস্টেমে আপনি একটি প্রিলোড ব্যবহার করতে পারেন, যেমন
LD_PRELOAD=/usr/lib/libtcmalloc_minimal.so.4 befour 5
বুনিয়াদি ব্যবহার: লক্ষ্য পর্যন্ত সমস্ত সংখ্যা উত্পন্ন এবং মুদ্রণ করুন:
befour target
বিকল্প:
-a লক্ষ্য নির্ধারণের সময় তৈরি হওয়া সমস্ত নম্বরও মুদ্রণ করুন-c "ক্যারি" (ডুপ) দিয়ে শুরু করা সমস্ত নম্বর মুদ্রণ করুন-f উত্পাদিত হয়নি এমন লক্ষ্য ছাড়িয়ে প্রথম সংখ্যাটি সন্ধান করুন এবং মুদ্রণ করুন-s লক্ষ্যটি উত্পন্ন করা হলেও বন্ধ করুন যদি সমস্ত নম্বর উত্পন্ন না করা হয়-Sলাইক -sএবং -fএকটি স্বয়ংক্রিয় লুপ। লক্ষ্য উত্পন্ন হওয়ার সাথে সাথে প্রথম সংখ্যাটি এখনও জেনারেট হয়নি এবং এটি নতুন লক্ষ্যটি তৈরি করুন-Eলক্ষ্য পৌঁছে গেলে তাত্ক্ষণিক প্রস্থান করবেন না। প্রথমে বর্তমান দৈর্ঘ্যের সমস্ত স্ট্রিং শেষ করুন-Oলক্ষ্য পর্যন্ত সমস্ত সংখ্যা পর্যন্ত স্ট্রিং আউটপুট করবেন না। লক্ষ্য জন্য স্ট্রিং-o অনুমোদিত নির্দেশাবলী (ডিফল্ট এ +-*/:-b numনিম্নতম আক্ষরিক যা ধাক্কা দেওয়া যায় (এতে ডিফল্ট 0)-B numসর্বাধিক আক্ষরিক যা ঠেলা যায় (ডিফল্টে 9)-r numসর্বনিম্ন অনুমোদিত মধ্যবর্তী ফলাফল। আন্ডারফ্লো এড়াতে ব্যবহৃত হয়। (ডিফল্ট INT32_MIN,-2147483648-R numসর্বোচ্চ অনুমোদিত মধ্যবর্তী ফলাফল। ওভারফ্লো এড়াতে ব্যবহৃত হয়। (ডিফল্ট INT32_MAX,2147483647-m memory (কেবলমাত্র লিনাক্স) প্রস্থান করুন যখন প্রায় অতিরিক্ত অতিরিক্ত মেমরি বরাদ্দ করা হয়
কিছু আকর্ষণীয় বিকল্প সংমিশ্রণ:
এই সমস্ত সংখ্যার চেয়ে লম্বা জেনারেটর প্রয়োজন এমন সবচেয়ে ছোট সংখ্যাকে লক্ষ্য এবং গণনা করার জন্য সমস্ত সংখ্যা তৈরি করুন:
befour -fE target
কেবলমাত্র লক্ষ্য (-s) তৈরি করুন, কেবলমাত্র লক্ষ্য (-O) মুদ্রণ করুন
befour -sO target
আপনার সিস্টেমে প্রদত্ত সময় এবং / অথবা মেমরির সীমাবদ্ধতায় সর্বাধিক সংখ্যাটি তৈরি করতে পারেন (এটি যদি আপনার চালনা ছেড়ে দেয় তবে এটি আপনার মেমরির বাইরে চলে যাবে the ):
befour -S 1
কখনও নেতিবাচক মধ্যবর্তী ফলাফল ব্যবহার না করে সমাধান তৈরি করুন ( 30932সবচেয়ে কম স্ট্রিংয়ের জন্য নেতিবাচক মধ্যবর্তী ফলাফলের প্রয়োজন এমন প্রথম মান):
befour -r0 target
কখনও ধাক্কা না দিয়ে সমাধানগুলি উত্পন্ন করুন 0( এটি কোনও সাবঅপটিমাল সমাধানের দিকে নিয়ে যায় না):
befour -b1 target
সহ সমাধান তৈরি করুন a..f (10..15):
befour -B15 target
ডুপ ব্যবহার না করে সমাধান তৈরি করুন :( -r0নেতিবাচক মধ্যবর্তী মানগুলি যেহেতু এই ক্ষেত্রে কখনই আকর্ষণীয় হয় না) যুক্ত করুন
befour -r0 -o "+-*/" target
সুনির্দিষ্ট ব্যবহার করে প্রদত্ত স্ট্রিং দৈর্ঘ্যের জন্য উত্পন্ন করা যায় না এমন প্রথম মানটি সন্ধান করুন + , -, *এবং /:
befour -ES -r0 -o "+-*/" 1
এটি প্রকৃতপক্ষে প্রথম কয়েকটি শর্ত তৈরি করে https://oeis.org/A181898 আলাদা করা শুরু করবে 14771কারণ আমরা কাটা বিভাগ ব্যবহার করি যাতে এই সংখ্যাটি OEIS সিরিজ হিসাবে 15 এর দৈর্ঘ্যের পরিবর্তে 13 স্ট্রিংয়ের সাহায্যে করা যায় প্রত্যাশা করে:
14771: 13: 99*9*9*4+9*4/
পরিবর্তে
14771: 15: 19+5*6*7*9+7*8+
যেহেতু কাটা বিভাগ ছাড়াই অর্থহীন বলে মনে হচ্ছে OEIS সিরিজটি ব্যবহার করে আরও ভাল উত্পন্ন করা যেতে পারে
befour -ES -r0 -o"+-*" 1
অনুমান করা বিভাগটি অকেজো থেকে যায় আমি স্মৃতি থেকে বেরিয়ে যাওয়ার আগে এটি আমাকে 3 টি অতিরিক্ত শর্ত দেয়:
10, 19, 92, 417, 851, 4237, 14771, 73237, 298609, 1346341, 6176426, 25622578
এই প্রোগ্রামটির আর একটি সংস্করণ বাহ্যিক ফাইলগুলিতে ডেটা অংশ সংরক্ষণ করে 135153107 এবং 675854293 যোগ করে যার পরে সমস্ত 32-বিট পূর্ণসংখ্যার উত্পন্ন করা হয়েছে।
befour.cpp
/*
Compile using something like:
g++ -Wall -O3 -march=native -std=gnu++11 -s befour.cpp -o befour
*/
#include <iostream>
#include <fstream>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
#include <limits>
#include <climits>
#include <cstdint>
#include <cstdlib>
#include <chrono>
#include <unordered_map>
using namespace std;
#ifdef __GNUC__
# define HOT __attribute__((__hot__))
# define COLD __attribute__((__cold__))
# define NOINLINE __attribute__((__noinline__))
# define LIKELY(x) __builtin_expect(!!(x),1)
# define UNLIKELY(x) __builtin_expect(!!(x),0)
#else // __GNUC__
# define HOT
# define COLD
# define NOINLINE
# define LIKELY(x) (x)
# define UNLIKELY(x) (x)
#endif // __GNUC__
#ifdef INT64
using Int = int64_t; // Supported value type
# ifndef OVERFLOW
using Int2 = __int128; // Do calculations in this type. Check overflow
# endif // OVERFLOW
#else // INT64
using Int = int32_t; // Supported value type
# ifndef OVERFLOW
using Int2 = int64_t; // Do calculations in this type. Check overflow
# endif // OVERFLOW
#endif // INT64
#ifdef OVERFLOW
using Int2 = Int;
#endif // OVERFLOW
// Supported value range
Int2 MIN = numeric_limits<Int>::lowest();
Int2 MAX = numeric_limits<Int>::max();
Int HALF_MIN, HALF_MAX;
// The initial values we can push
Int ATOM_MIN = 0;
Int ATOM_MAX = 9;
bool all = false; // Output all reached values
bool all_carry = false; // Output all values reachable using carry
bool early_exit = true; // Exit before finishing level if goal reached
bool find_hole = false; // Look for first unconstructed > target
bool output = true; // Output [1..target] instead of just target
bool single = false; // Only go for target instead of [1..target]
bool explore = false; // Don't stop, increase N until out of memory
bool do_dup = false; // Use operator :
bool do_multiply= false; // Use operator *
bool do_add = false; // Use operator +
bool do_subtract= false; // Use operator -
bool do_divide = false; // Use operator /
char const* operators = "+-*/:"; // Use these operators
size_t max_mem = SIZE_MAX; // Stop if target memory reached
size_t const MEM_CHECK = 1000000;
chrono::steady_clock::time_point start;
NOINLINE size_t get_memory(bool set_base_mem = false) {
static size_t base_mem = 0;
size_t const PAGE_SIZE = 4096;
// Linux specific. Won't hurt on other systems, just gets no result
size_t mem = 0;
std::ifstream statm;
statm.open("/proc/self/statm");
statm >> mem;
mem *= PAGE_SIZE;
if (set_base_mem) base_mem = mem;
else mem -= base_mem;
return mem;
}
// Handle commandline options.
// Simplified getopt for systems that don't have it in their library (Windows..)
class GetOpt {
private:
string const options;
char const* const* argv;
int nextchar = 0;
int optind = 1;
char ch = '?';
char const* optarg = nullptr;
public:
int ind() const { return optind; }
char const* arg() const { return optarg; }
char option() const { return ch; }
GetOpt(string const options_, char const* const* argv_) :
options(options_), argv(argv_) {}
char next() {
while (1) {
if (nextchar == 0) {
if (!argv[optind] ||
argv[optind][0] != '-' ||
argv[optind][1] == 0) return ch = 0;
if (argv[optind][1] == '-' && argv[optind][2] == 0) {
++optind;
return ch = 0;
}
nextchar = 1;
}
ch = argv[optind][nextchar++];
if (ch == 0) {
++optind;
nextchar = 0;
continue;
}
auto pos = options.find(ch);
if (pos == string::npos) ch = '?';
else if (options[pos+1] == ':') {
if (argv[optind][nextchar]) {
optarg = &argv[optind][nextchar];
} else {
optarg = argv[++optind];
if (!optarg) return ch = options[0] == ':' ? ':' : '?';
}
++optind;
nextchar = 0;
}
return ch;
}
}
};
using ms = chrono::milliseconds;
Int missing, N;
size_t cached, cached_next;
uint8_t const CARRY_MASK = '\x80';
uint8_t const LITERAL = 0;
struct How {
// Describes how to construct a number
Int left;
Int right;
uint8_t ops, op;
How(uint8_t ops_, uint8_t op_, Int carry_=0, Int left_=0, Int right_=0) :
left(left_),
right(right_),
ops(ops_),
op(carry_ ? CARRY_MASK | op_ : op_)
{}
How() = default;
How(How&&) = default;
How& operator=(How&&) = default;
static How const* predict(Int carry, Int value, int& ops);
static void print_predicted(ostream& out, Int carry, Int value, How const* Value = nullptr);
void print(ostream& out, Int carry = 0, bool length = false) const;
};
ostream& operator<<(ostream& out, How const& how) {
how.print(out, 0, true);
return out;
}
using NumSet = vector<Int>;
using NumSets = vector<NumSet>;
struct Known: public unordered_map<Int, How>
{
void store(NumSet& L, Int accu, uint8_t ops, uint8_t op,
Int left=0, Int carry_right=0, Int right=0) {
++cached;
emplace(accu, How(ops, op, carry_right, left, right));
// operator[](accu) = How(ops, op, carry_right, left, right);
L.emplace_back(accu);
}
void maybe_store(Known const& known0, NumSet& L,
Int accu, uint8_t ops, uint8_t op,
Int carry_left, Int left, Int carry_right, Int right) {
if (count(accu)) return;
if (carry_left) {
auto found = known0.find(accu);
// If we can do as good or better without carry use that
if (found != known0.end() && found->second.ops <= ops) return;
}
store(L, accu, ops, op, left, carry_right, right);
if (carry_left) return;
if (single) {
if (UNLIKELY(accu == N)) known0.maybe_explore();
} else if (1 <= accu && accu <= N) --missing;
}
NOINLINE void maybe_explore() const COLD {
--missing;
if (explore && early_exit) do_explore();
}
NOINLINE void do_explore() const COLD {
auto i = N;
while (i < MAX && count(++i));
auto end = chrono::steady_clock::now();
auto elapsed = chrono::duration_cast<ms>(end-start).count();
cerr << "Found " << N << " at " << elapsed / 1000. << " s";
auto mem = get_memory();
if (mem) cerr << " (" << mem / 1000 / 1000. << " MB)";
if (i < MAX || !count(i)) {
cerr << ", now looking for " << i << endl;
N = i;
++missing;
} else
cerr << ", every value has now been generated" << endl;
}
};
struct KnowHow {
// Describes all numbers we know how to construct
NumSets num_sets;
Known known;
KnowHow() = default;
~KnowHow() = default;
KnowHow(KnowHow const&) = delete;
KnowHow& operator=(KnowHow const&) = delete;
};
// Describes all numbers we know how to construct for a given carry
// Key 0 is special: the numbers we can construct without carry (the solutions)
unordered_map<Int, KnowHow> known_how;
// Try to predict if a subtree is a delayed How and avoid descending
// into it (since it may not exist yet)
How const* How::predict(Int carry, Int value, int& ops) {
How* Value;
if (carry) {
if (value == carry) {
Value = nullptr;
ops = 0;
} else {
Value = &known_how.at(carry).known.at(value);
ops = Value->ops;
}
} else {
if (ATOM_MIN <= value && value <= ATOM_MAX) {
Value = nullptr;
ops = 0;
} else {
Value = &known_how.at(0).known.at(value);
ops = Value->ops;
}
}
return Value;
}
void How::print_predicted(ostream& out, Int carry, Int value, How const* Value) {
if (Value) Value->print(out, carry);
else if (carry) out << ":";
else if (value > 9) out << static_cast<char>(value-10+'a');
else out << value;
}
void How::print(ostream& out, Int carry_left, bool length) const {
if (length) out << 2*ops+1 << ": ";
Int carry_right = 0;
auto op_ = op;
switch(op_) {
case LITERAL:
How::print_predicted(out, 0, left);
break;
case '*' | CARRY_MASK:
case '/' | CARRY_MASK:
case '+' | CARRY_MASK:
case '-' | CARRY_MASK:
carry_right = left;
op_ &= ~CARRY_MASK;
// Intentional drop through
case '*':
case '/':
case '+':
case '-':
{
int left_ops, right_ops;
auto Left = How::predict(carry_left, left, left_ops);
// Int right = 0;
auto Right = How::predict(carry_right, right, right_ops);
// Sanity check: tree = left_tree + root + right_tree
if (ops != left_ops + right_ops +1) {
char buffer[80];
snprintf(buffer, sizeof(buffer),
"Broken number %d %c %d, length %d != %d + %d + 1",
static_cast<int>(left), op_, static_cast<int>(right),
ops, left_ops, right_ops);
throw(logic_error(buffer));
}
How::print_predicted(out, carry_left, left, Left);
How::print_predicted(out, carry_right, right, Right);
}
// Intentional drop through
case ':':
out << op_;
break;
default:
throw(logic_error("Unknown op " + string{static_cast<char>(op_)}));
break;
}
}
// carryX indicates Xv was reached using carry. If not we also know [L, known] is known_how[0]
// carryY indicates Y was reached using carry (carryY == Xv if so)
void combine(NumSet& L, Known& known, Known const& known0, int ops, Int carryX, Int2 Xv, Int carryY, NumSet const&Y) HOT;
void combine(NumSet& L, Known& known, Known const& known0, int ops, Int carryX, Int2 Xv, Int carryY, NumSet const&Y) {
for (Int Yv: Y) {
// Yv == 0 can never lead to an optimal calculation
if (Yv == 0) continue;
Int2 accu;
if (do_multiply) {
accu = Xv * Yv;
if (accu <= MAX && accu >= MIN)
known.maybe_store(known0, L, accu, ops, '*', carryX, Xv, carryY, Yv);
}
if (do_add) {
accu = Xv + Yv;
if (accu <= MAX && accu >= MIN)
known.maybe_store(known0, L, accu, ops, '+', carryX, Xv, carryY, Yv);
}
if (do_subtract) {
accu = Xv - Yv;
if (accu <= MAX && accu >= MIN)
known.maybe_store(known0, L, accu, ops, '-', carryX, Xv, carryY, Yv);
}
if (do_divide) {
accu = Xv / Yv;
if (accu <= MAX && accu >= MIN)
known.maybe_store(known0, L, accu, ops, '/', carryX, Xv, carryY, Yv);
}
}
}
// value was constructed using a carry if and only if value != 0
NumSet const& level(KnowHow& known_how0, Int value, int ops) HOT;
NumSet const& level(KnowHow& known_how0, Int value, int ops) {
auto& from_value = known_how[value];
if (from_value.num_sets.size() <= static_cast<size_t>(ops)) {
auto& known = from_value.known;
if (from_value.num_sets.size() != static_cast<size_t>(ops)) {
if (value == 0 || ops != 1)
throw(logic_error("Unexpected level skip"));
// This was because of delayed carry creation.
// The delay is over. Create the base case
from_value.num_sets.resize(ops+1);
known.store(from_value.num_sets[0], value, 0, ':', value);
} else
from_value.num_sets.resize(ops+1);
auto& L = from_value.num_sets[ops];
if (ops == 0) {
if (value) {
known.store(L, value, ops, ':', value);
} else {
for (auto i = ATOM_MIN; i <= ATOM_MAX; ++i) {
if (single) {
if (i == N) --missing;
} else {
if (0 < i && i <= N) --missing;
}
known.store(L, i, 0, LITERAL, i);
}
}
} else {
auto& known0 = known_how0.known;
// for (auto k=ops-1; k>=0; --k) {
for (auto k=0; k<ops; ++k) {
auto const& X = from_value.num_sets[ops-1-k];
auto const& Y = known_how0.num_sets[k];
for (Int Xv: X) {
// Plain combine must come before carry combine so a plain
// solution will prune a same length carry solution
combine(L, known, known0, ops, value, Xv, 0, Y);
if (!missing && early_exit) goto DONE;
if (do_dup && (Xv > ATOM_MAX || Xv < ATOM_MIN)) {
// Dup Xv, construct something using k operators, combine
if (k == 0 && Xv != 0) {
// Delay creation of carry known_how[Xv] for 1 level
// This is purely a memory and speed optimization
// Subtraction gives 0 which is never optimal
// Division gives 1 which is never optimal
// Multiplication gives Xv ** 2
// Could be == Xv if Xv== 0 or Xv == 1, but will be
// pruned by atom - atom or atom / atom
Int2 accu = Xv;
accu *= accu;
if (accu <= MAX && accu >= MIN) {
known.maybe_store(known0, L, accu, ops, '*',
value, Xv, Xv, Xv);
}
// Addition gives Xv * 2 (!= Xv)
if (HALF_MIN <= Xv && Xv <= HALF_MAX)
known.maybe_store(known0, L, 2*Xv, ops, '+',
value, Xv, Xv, Xv);
} else {
auto& Z = level(known_how0, Xv, k);
combine(L, known, known0, ops, value, Xv, Xv, Z);
}
if (!missing && early_exit) goto DONE;
}
if (max_mem != SIZE_MAX && cached > cached_next) {
cached_next = cached + MEM_CHECK;
if (get_memory() >= max_mem) goto DONE;
}
}
}
}
// L.shrink_to_fit();
}
DONE:
return from_value.num_sets[ops];
}
void my_main(int argc, char const* const* argv) {
GetOpt options("acfm:sSEOo:b:B:r:R:", argv);
while (options.next())
switch (options.option()) {
case 'a': all = true; break;
case 'b': {
auto tmp = atoll(options.arg());
ATOM_MIN = static_cast<Int>(tmp);
if (static_cast<long long int>(ATOM_MIN) != tmp)
throw(range_error("ATOM_MIN is out of range"));
break;
}
case 'B': {
auto tmp = atoll(options.arg());
ATOM_MAX = static_cast<Int>(tmp);
if (static_cast<long long int>(ATOM_MAX) != tmp)
throw(range_error("ATOM_MAX is out of range"));
break;
}
case 'c': all_carry = true; break;
case 'f': find_hole = true; break;
case 'm': max_mem = atoll(options.arg()); break;
case 'S': explore = true; // intended drop through to single
case 's': single = true; break;
case 'o': operators = options.arg(); break;
case 'E': early_exit = false; break;
case 'r': {
auto tmp = atoll(options.arg());
MIN = static_cast<Int>(tmp);
if (static_cast<long long int>(MIN) != tmp)
throw(range_error("MIN is out of range"));
break;
}
case 'R': {
auto tmp = atoll(options.arg());
MAX = static_cast<Int>(tmp);
if (static_cast<long long int>(MAX) != tmp)
throw(range_error("MAX is out of range"));
break;
}
case 'O': output = false; break;
default:
cerr << "usage: " << argv[0] << " [-a] [-c] [-f] [-D] [-E] [-O] [-s] [-b atom_min] [-B atom_max] [r range_min] [-R range_max] [-m max_mem] [max]" << endl;
exit(EXIT_FAILURE);
}
// Avoid silly option combinations
if (MIN > MAX) throw(logic_error("MIN above MAX"));
if (ATOM_MIN > ATOM_MAX) throw(logic_error("ATOM_MIN above ATOM_MAX"));
if (ATOM_MIN < 0) throw(range_error("Cannot represent negative atoms"));
if (ATOM_MAX > 35) throw(range_error("Cannot represent atoms > 35"));
if (ATOM_MIN < MIN) throw(range_error("ATOM_MIN is out of range"));
if (ATOM_MAX > MAX) throw(range_error("ATOM_MAX is out of range"));
HALF_MIN = MIN / 2;
HALF_MAX = MAX / 2;
for (auto ops=operators; *ops; ++ops)
switch(*ops) {
case '*': do_multiply = true; break;
case '/': do_divide = true; break;
case '+': do_add = true; break;
case '-': do_subtract = true; break;
case ':': do_dup = true; break;
default:
throw(logic_error("Unknown operator"));
}
long long int const NN =
options.ind() < argc ? atoll(argv[options.ind()]) : 1;
if (NN < MIN || NN > MAX)
throw(range_error("Target number is out of range"));
N = NN;
if (N < 1) {
single = true;
output = false;
}
cerr << "N=" << N << ", using " << sizeof(Int) * CHAR_BIT << " bits without overflow" << endl;
missing = single ? 1 : N;
cached = cached_next = 0;
auto& known_how0 = known_how[0];
auto& known = known_how0.known;
auto mem = get_memory(true);
if (!mem && max_mem != SIZE_MAX)
throw(runtime_error("Cannot get memory usage on this system"));
// Start calculation
start = chrono::steady_clock::now();
// Fill in initial values [0..9]
level(known_how0, 0, 0);
// Grow number of allowed operations until all requested numbers are reached
// for (auto ops=1; ops <=5; ++ops) {
for (auto ops=1;;++ops) {
if (missing == 0) {
if (!explore) break;
known_how0.known.do_explore();
if (missing == 0) break;
}
if (max_mem != SIZE_MAX && get_memory() >= max_mem) break;
auto end = chrono::steady_clock::now();
auto elapsed = chrono::duration_cast<ms>(end-start).count();
cerr << "Reaching for " << 2*ops+1 << " instructions at " << elapsed/1000. << " s";
if (mem) cerr << " (" << get_memory() / 1000 / 1000. << " MB)";
cerr << endl;
auto old_cached = cached;
level(known_how0, 0, ops);
if (cached == old_cached) {
cerr << "Oops, all possible numbers have been generated and we still weren't finished" << endl;
break;
}
}
// We are done generating all numbers.
auto end = chrono::steady_clock::now();
// Report the result
// length = 2*ops + 1
Int limit = known_how0.num_sets.size()*2-1;
cerr << "Some numbers needed " << limit << " instructions" << endl;
auto elapsed = chrono::duration_cast<ms>(end-start).count();
start = end;
stringstream out;
out << "Calculation: " << elapsed/1000. << " s\n";
for (auto i = output ? 1 : N; i <= N; ++i) {
if (single || missing) {
auto got = known.find(i);
if (got != known.end())
cout << i << ": " << got->second << "\n";
else
cout << i << " not generated\n";
} else
cout << i << ": " << known.at(i) << "\n";
}
if (output) {
end = chrono::steady_clock::now();
elapsed = chrono::duration_cast<ms>(end-start).count();
start = end;
out << "Printing: " << elapsed/1000. << " s\n";
}
if (find_hole) {
Int hole;
for (auto i = single ? 1 : N+1; 1; ++i) {
if (!known_how0.known.count(i) || i == 0) {
hole = i;
break;
}
}
out << "First missing value " << hole << "\n";
end = chrono::steady_clock::now();
elapsed = chrono::duration_cast<ms>(end-start).count();
start = end;
out << "Missing: " << elapsed/1000. << " s\n";
}
if (all) {
for (auto const& entry: known_how0.known) {
cout << entry.first << ": " << entry.second << "\n";
}
end = chrono::steady_clock::now();
elapsed = chrono::duration_cast<ms>(end-start).count();
start = end;
out << "All: " << elapsed/1000. << " s\n";
}
if (all_carry) {
for (auto const& carry: known_how) {
auto carry_left = carry.first;
if (carry_left == 0) continue;
cout << "Carry " << carry_left << "\n";
for (auto const& how: carry.second.known) {
cout << " " << how.first << ": ";
how.second.print(cout, carry_left, true);
cout << "\n";
}
}
end = chrono::steady_clock::now();
elapsed = chrono::duration_cast<ms>(end-start).count();
start = end;
out << "All carry: " << elapsed/1000. << " s\n";
}
mem = get_memory();
if (mem) cerr << "used about " << mem / 1000 / 1000. << " MB\n";
cerr << out.str();
cerr << "Cached " << cached << " results = " << known.size() << " plain + " << cached - known.size() << " carry" << endl;
}
int main(int argc, char const* const* argv) {
try {
my_main(argc, argv);
} catch(exception& e) {
cerr << "Error: " << e.what() << endl;
quick_exit(EXIT_FAILURE);
}
// Cleaning up the datastructures can take ages
quick_exit(EXIT_SUCCESS);
}
কিছু পরীক্ষার কেস:
1: 1: 111: 3: 29+26: 5: 29*8+27: 3: 39*100: 5: 19+:*2431: 9: 56*9*9*1+3727: 9: 69*7+:*6+86387: 11: 67*:*1-7*7*265729: 11: 39*:*:*2/9+265620: 13: 99*::*6/*7+3*1921600: 9: 77*:*:*3/21523360: 9: 99*:*:*2/57168721: 11: 99*6+:*8-:*30932: 11: 159*-:4*:*+
56সরাসরি স্ট্যাকের মধ্যে ধাক্কা না দিতে পারি, তবে আমরা কীভাবে78স্ট্যাকের মধ্যে ঠেলাতে পারি?