fork download

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
 
typedef unsigned long long hash_t;
const int PWD_LEN = 12;
 
char password[PWD_LEN+1];
 
template<typename T> T fast_pow(T x, T y)
{
	if (y == 0)
		return 1;
	T half = fast_pow(x, y / 2);
	if (y % 2 == 0)
		return half*half;
	else
		return half*half*x;
}
 
hash_t(*f_tab[])(hash_t) = {
	[](hash_t x)->hash_t { return x * 3; },
	[](hash_t x)->hash_t { return x * 4893147; },
	[](hash_t x)->hash_t { return _rotl64(x, 15); },
	[](hash_t x)->hash_t { return x + 32781696542221LLU; },
	[](hash_t x)->hash_t { return x ^ 0x83ff8af031d01deLLU; },
	[](hash_t x)->hash_t { return _byteswap_uint64(x); },
	[](hash_t x)->hash_t { return fast_pow(x | 1, 3ULL) ^ (x & 1); },
	[](hash_t x)->hash_t { return fast_pow(x | 1, 5ULL) ^ (x & 1); },
	[](hash_t x)->hash_t { return ~x; },
	[](hash_t x)->hash_t { return x - 123; },
};
 
hash_t get_hash(const char* password, hash_t x)
{
	while (*password)
		x = f_tab[*password++ - '0'](x);
	return x;
}
 
void wrong()
{
	puts("Wrong pin!");
	exit(0);
}
 
void correct()
{
	puts("Correct pin! gz!");
	exit(0);
}
 
int main()
{
	printf("Enter pin code ([0-9]{%d}): ", PWD_LEN);
	scanf_s("%s", password, PWD_LEN+1);
 
	if (strlen(password) != PWD_LEN)
		wrong();
 
	for (char *ptr = password; *ptr; ptr++)
		if (!isdigit(*ptr))
			wrong();
 
	if (get_hash(password, 0x688e3d039d29a28eULL) == 0x8beda56841260d0d)
		correct();
	else
		wrong();
}

prog.cpp:23:16: error: type ‘__lambda0’ with no linkage used to declare function ‘hash_t __lambda0::operator()(hash_t) const’ with linkage [-fpermissive]
  [](hash_t x)->hash_t { return x * 3; },
                ^
prog.cpp:23:39: warning: lambda expressions only available with -std=c++11 or -std=gnu++11 [enabled by default]
  [](hash_t x)->hash_t { return x * 3; },
                                       ^
prog.cpp:24:16: error: type ‘__lambda1’ with no linkage used to declare function ‘hash_t __lambda1::operator()(hash_t) const’ with linkage [-fpermissive]
  [](hash_t x)->hash_t { return x * 4893147; },
                ^
prog.cpp:24:45: warning: lambda expressions only available with -std=c++11 or -std=gnu++11 [enabled by default]
  [](hash_t x)->hash_t { return x * 4893147; },
                                             ^
prog.cpp:25:16: error: type ‘__lambda2’ with no linkage used to declare function ‘hash_t __lambda2::operator()(hash_t) const’ with linkage [-fpermissive]
  [](hash_t x)->hash_t { return _rotl64(x, 15); },
                ^
prog.cpp: In lambda function:
prog.cpp:25:45: error: ‘_rotl64’ was not declared in this scope
  [](hash_t x)->hash_t { return _rotl64(x, 15); },
                                             ^
prog.cpp: At global scope:
prog.cpp:25:48: warning: lambda expressions only available with -std=c++11 or -std=gnu++11 [enabled by default]
  [](hash_t x)->hash_t { return _rotl64(x, 15); },
                                                ^
prog.cpp:26:16: error: type ‘__lambda3’ with no linkage used to declare function ‘hash_t __lambda3::operator()(hash_t) const’ with linkage [-fpermissive]
  [](hash_t x)->hash_t { return x + 32781696542221LLU; },
                ^
prog.cpp:26:55: warning: lambda expressions only available with -std=c++11 or -std=gnu++11 [enabled by default]
  [](hash_t x)->hash_t { return x + 32781696542221LLU; },
                                                       ^
prog.cpp:27:16: error: type ‘__lambda4’ with no linkage used to declare function ‘hash_t __lambda4::operator()(hash_t) const’ with linkage [-fpermissive]
  [](hash_t x)->hash_t { return x ^ 0x83ff8af031d01deLLU; },
                ^
prog.cpp:27:58: warning: lambda expressions only available with -std=c++11 or -std=gnu++11 [enabled by default]
  [](hash_t x)->hash_t { return x ^ 0x83ff8af031d01deLLU; },
                                                          ^
prog.cpp:28:16: error: type ‘__lambda5’ with no linkage used to declare function ‘hash_t __lambda5::operator()(hash_t) const’ with linkage [-fpermissive]
  [](hash_t x)->hash_t { return _byteswap_uint64(x); },
                ^
prog.cpp: In lambda function:
prog.cpp:28:50: error: ‘_byteswap_uint64’ was not declared in this scope
  [](hash_t x)->hash_t { return _byteswap_uint64(x); },
                                                  ^
prog.cpp: At global scope:
prog.cpp:28:53: warning: lambda expressions only available with -std=c++11 or -std=gnu++11 [enabled by default]
  [](hash_t x)->hash_t { return _byteswap_uint64(x); },
                                                     ^
prog.cpp:29:16: error: type ‘__lambda6’ with no linkage used to declare function ‘hash_t __lambda6::operator()(hash_t) const’ with linkage [-fpermissive]
  [](hash_t x)->hash_t { return fast_pow(x | 1, 3ULL) ^ (x & 1); },
                ^
prog.cpp:29:65: warning: lambda expressions only available with -std=c++11 or -std=gnu++11 [enabled by default]
  [](hash_t x)->hash_t { return fast_pow(x | 1, 3ULL) ^ (x & 1); },
                                                                 ^
prog.cpp:30:16: error: type ‘__lambda7’ with no linkage used to declare function ‘hash_t __lambda7::operator()(hash_t) const’ with linkage [-fpermissive]
  [](hash_t x)->hash_t { return fast_pow(x | 1, 5ULL) ^ (x & 1); },
                ^
prog.cpp:30:65: warning: lambda expressions only available with -std=c++11 or -std=gnu++11 [enabled by default]
  [](hash_t x)->hash_t { return fast_pow(x | 1, 5ULL) ^ (x & 1); },
                                                                 ^
prog.cpp:31:16: error: type ‘__lambda8’ with no linkage used to declare function ‘hash_t __lambda8::operator()(hash_t) const’ with linkage [-fpermissive]
  [](hash_t x)->hash_t { return ~x; },
                ^
prog.cpp:31:36: warning: lambda expressions only available with -std=c++11 or -std=gnu++11 [enabled by default]
  [](hash_t x)->hash_t { return ~x; },
                                    ^
prog.cpp:32:16: error: type ‘__lambda9’ with no linkage used to declare function ‘hash_t __lambda9::operator()(hash_t) const’ with linkage [-fpermissive]
  [](hash_t x)->hash_t { return x - 123; },
                ^
prog.cpp:32:41: warning: lambda expressions only available with -std=c++11 or -std=gnu++11 [enabled by default]
  [](hash_t x)->hash_t { return x - 123; },
                                         ^
prog.cpp: In function ‘int main()’:
prog.cpp:57:35: error: ‘scanf_s’ was not declared in this scope
  scanf_s("%s", password, PWD_LEN+1);
                                   ^
prog.cpp: In lambda function:
prog.cpp:25:48: warning: control reaches end of non-void function [-Wreturn-type]
  [](hash_t x)->hash_t { return _rotl64(x, 15); },
                                                ^
prog.cpp: In lambda function:
prog.cpp:28:53: warning: control reaches end of non-void function [-Wreturn-type]
  [](hash_t x)->hash_t { return _byteswap_uint64(x); },
                                                     ^

Standard output is empty