C ++, 가까운 컴퓨터의 모든 메모리를 폭발
계산에서 부호있는 32 비트 정수의 오버플로가 발생하지 않는 가장 짧은 문자열을 생성합니다 (따라서 모든 중간 결과가 범위 내에 있음) [-2147483648, 2147483647]
내 시스템에서 이것은 최대를 포함하여 모든 숫자에 대한 솔루션을 생성합니다. 483432 1.8G 메모리를 사용하는 동안 30 초를 . 숫자가 높을수록 메모리 사용량이 빠르게 폭발합니다. 시스템에서 처리 할 수있는 가장 높은 숫자는5113906 입니다. 계산에는 거의 9 분 24GB가 걸립니다. 완료되면 내부적 398499338으로 모든 32 비트 정수의 약 9 % (양수 및 음수)에 대한 솔루션이 있습니다.
C ++ 11 컴파일러가 필요합니다. 리눅스에서 컴파일 :
g++ -Wall -O3 -march=native -std=gnu++11 -s befour.cpp -o befour
-DINT64중간 결과에 32 비트 대신 64 비트 정수 범위를 사용하는 옵션으로 추가 합니다 (시간과 메모리가 약 50 % 더 많이 사용됨). 내장 된 128 비트 유형이 필요합니다. gcc 유형을 변경해야 할 수도 있습니다__int128 . [1..483432]더 큰 중간 결과를 허용 하여 범위가 변경되는 결과는 없습니다.
더하다 -DOVERFLOW오버플로를 확인하기 위해 더 큰 정수 유형을 사용하지 않는 옵션으로 . 오버플로 및 값 줄 바꿈을 허용하는 효과가 있습니다.
시스템에 tcmalloc ( https://github.com/gperftools/gperftools )이있는 경우 일반적으로 약간 빠르며 약간 적은 메모리를 사용하는 프로그램을 생성 할 수 있습니다. 일부 UNIX 시스템에서는 예를 들어 사전로드를 사용할 수 있습니다.
LD_PRELOAD=/usr/lib/libtcmalloc_minimal.so.4 befour 5
기본 사용법 : 모든 숫자를 생성하고 대상까지 인쇄하십시오.
befour target
옵션 :
-a 대상을 운동하는 동안 생성 된 모든 숫자를 인쇄하십시오-c "캐리"(dup)로 시작하여 생성 된 모든 숫자도 인쇄하십시오.-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
주어진 시간 및 / 또는 메모리 제약 조건에서 시스템에서 생성 할 수있는 가장 높은 숫자를 찾으십시오 (이를 실행하면 시스템 메모리가 부족합니다. 마지막 "찾는"출력에서 1을 빼고 마지막 안전 값으로 표시합니다. ) :
befour -S 1
음수 중간 결과를 사용하지 않고 솔루션 생성 ( 30932가장 짧은 문자열에 대해 음수 중간 결과가 필요한 첫 번째 값) :
befour -r0 target
추진하지 않고 솔루션을 생성하십시오 0(이것은 차선책으로 이어지지는 않습니다).
befour -b1 target
다음을 포함한 솔루션을 생성하십시오 a..f (10..15).
befour -B15 target
dup을 사용하지 않고 솔루션 생성 :( -r0이 경우에는 음의 중간 값이 절대로 흥미롭지 않기 때문에 추가 )
befour -r0 -o "+-*/" target
사용하여 단지 주어진 문자열의 길이를 생성 할 수 없습니다 첫 번째 값 찾기 +, -, *과를 /:
befour -ES -r0 -o "+-*/" 1
이것은 실제로 https://oeis.org/A181898 의 처음 몇 용어를 생성 하지만 14771OEIS 시리즈로 길이 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넣을 수 있습니까?