Probably the best you can do is to use Curve25519 to derive a secret and then use the secret to derive a key and IV which are used to encrypt the data symmetrically with an AEAD. That would expand your message about 48 bytes but would be smaller and more secure than trying use use RSA and OAEP. Specifically, I would suggest you use the NaCl crypto_box transform because this is a well-known, secure library with many implementations and the algorithms are considered trusted. It uses Salsa20 and Poly1305 for the AEAD, which are secure for this use. It may expand your message slightly more than 48 bytes, but even if it expanded it 64 bytes, you'd end up with a 128-byte value for a 64-byte message, which is smaller than anything using a 3072-bit RSA key (which is the minimum for 128-bit security). This is technically a hybrid approach, but in general, everybody uses hybrid approaches for asymmetric encryption because they're well known and secure, as well as being substantially faster than the alternatives. I wouldn't recommend sending actual messages as the message in RSA-OAEP. That's larger than you want, and I wouldn't be surprised if there are potentially interesting attacks on that approach.

First of all, a few misconceptions: You've got the way public key crypto (which is in fact called "public key" or "asymmetric", not "private key") works a bit wrong. The public key can encrypt and verify but can't sign or decrypt. The private key is the reverse. The sensitive operation in both cases - the one that only an authorized person should be able to do - requires the private key (anybody can encrypt, but only one can decrypt and reveal whatever secrets were encrypted; anybody can verify a signature if they get one, but only one is able to say "I hereby attach my seal to this message, that it may be known to come from me and not get tampered with en route"). Hashing isn't encryption, in any useful sense. Not only is there no corresponding decryption routine, but also, hash functions produce an output with a fixed length, regardless of the input length (encryption functions always product an output at least as long as the input, and many can't actually take an arbitrary length input at all without some way to repeatedly apply the basic operation to each data chunk in sequence, known as a "block cipher mode of operation"). Hashing also usually does not use any form of "key". You don't specify why you'd need a keyed hash at all in your actual question, but I'm going to assume it's for the usual reasons you might want one: to generate a message authentication code (MAC) of some kind, such as an HMAC (Hash-based MAC). With that said: While there are no cryptographic primitives (algorithms that can implement a single cryptographic operation) that can both encrypt and hash but use two different keys, there are cryptographic "constructions" or "suites" that do this. For example, TLS (the security protocol behind HTTPS and some other protocols) can use two symmetric keys in some cases, one for bulk data encryption and decryption, and the other for computing MACs of that data. Alternatively, TLS (and other cryptosystems) can extend various ciphers in ways that add message authentication on top of encryption using the same key, and usually it's also possible to MAC some data without encrypting it. This is known as "Authenticated Encryption with Associated Data" (AEAD), and there are a few common ways to do it (Galois/Counter Mode, a block cipher mode of operation that adds AEAD to any block cipher, is commonly used with AES in, among many other things, securing your communication to this very website). However, while AEAD can both encrypt/decrypt and MAC (sort of like signing)/verify, and can MAC data that is not actually encrypted as well as data that is, AEAD uses the same key for everything. Finally, and included only for completeness' sake, you can build something not entirely unlike a hashing algorithm using a cipher (encryption algorithm). If you take the message to "hash" and use it as the encryption key for some cipher, and use them (either without any initialization vector or nonce, or with a fixed one which thus technically is not a nonce) to encrypt a message already known to both parties (typically publicly known, or at least not really secret), you can produce something that is technically a ciphertext but which is used like a hash digest. Please don't do this; secure hash algorithms are as good or better at everything you might want to use this approach for. Like a hash, this process is deterministic: assuming the cipher and message are held constant, any given secret will produce the same ciphertext. Like a hash, this process is irreversible; assuming the cipher is secure, there's no way to derive the key used (except by brute force, which should be impractical) even though you know both the plaintext message and the ciphertext (and indeed know many such pairs for different keys). In a secure hash, the process is collision-resistant; that is hopefully the case here too (it is only possible via brute force to find two different keys such that they encrypt the same message to the same ciphertext). However, that's not necessarily something one specifically tests ciphers for. In a secure hash, the algorithm is resistant to pre-image attacks (given any digest, it's only possible by brute force to find an input that produces it); this is probably also true for these cipher-based "hashes". Unlike a typical secure hash algorithm, the length of the secret is strictly restricted (ciphers typically only accept a small range, or single value, key size).

Decided as follows: def stop_service(): pass def restart_service(): pass def start_service(): pass def set_reg_key(): pass def disable_agent_adapter_net_int(): pass def enable_agent_adapter_net_int(): pass method = { "stop-service": stop_service, "restart-service": restart_service, "start-service": start_service, "set-reg-key": set_reg_key, "disable-agent-adapter-net-int": disable_agent_adapter_net_int, "enable-agent-adapter-net-int": enable_agent_adapter_net_int } method"stop-service" And if a new method is to be added, it is very simple to add the key to the vocabulary and the method in question - very simple and without any large branches)

I'm not writing the code. The idea:Find a point that will definitely be inside the shell (average across all coordinates, for example)move all coordinates to ensure that the centre is (0.0). It's unbelievable. Disorder all points first to the polar corner, with parity on the moduleConnecting the points from the very first in that order. Connect 1 to the lastThen it's impossible to cross on the 1st corner. And different, because we're going to the nearest.P.S., sort carefully) there are many nasty calculations

The positioning in the text files has already been written in the commentary - https://ru.stackoverflow.com/users/182825/ant ♪ Anyway, your challenges. fseek They're putting a position in the file just at the beginning or the end, and it's going to be all right here https://msdn.microsoft.com/ru-ru/library/75yw9bf3.aspx : Properly searching 0 relative to any origin) In addition to one challenge:fseek(file, 8, SEEK_END); You're trying to get out of the file, 8 bytes further than it ends. This is not prohibited in principle (see above). https://msdn.microsoft.com/ru-ru/library/75yw9bf3.aspx but empty places will be filled with zeros. Is that exactly what you want to behave?if (file == NULL) { fclose(file); Don't close. not open file. That's what it says. https://msdn.microsoft.com/ru-ru/library/fxfsw25t.aspx :Fclose's function is closing the stream. If the stream parameter is NULL, the inadmissible parameter shall be produced as described in the parameter verification section. If performance can continue, fclose sets errno in EINVAL and returns EOF. It is recommended that the stream indicator be always checked before the function is challenged. file = fopen(filename, "w"); fclose(file); file = fopen(filename, "r"); Here you create an empty file and open it for reading. What can I read? file = fopen(filename, "w"); fclose(file); file = fopen(filename, "r+"); There's an empty file here, then it opens for recording and reading. But it's a challenge to make-- file = fopen(filename, "w+"); (See. https://msdn.microsoft.com/ru-ru/library/yeby3zcb.aspx )

That's how it's about half-sized until a couple of chis get caught. Then the process goes back. Balance is expressed that the size of the groups is not more than 1. The merger is carried out through the rotation of the first two numbers from the two groups, their comparison and transmission to the resulting many smaller numbers. 1 -8 3 7 4 11 0 13 -2 6 1 -8 3 7 4 | 11 0 13 -2 6 | | 1 -8 3 | 7 4 | 11 0 13 | -2 6 | | 1 -8 | 3 | 4 7 | 11 0 | 13 | -2 6 | | | | | -8 1 | 3 | 4 7 | 0 11 | 13 | -2 6 | | | -8 1 3 | 4 7 | 0 11 13 | -2 6 | -8 1 3 4 7 | -2 0 6 11 13 -8 -2 0 1 3 4 6 7 11 13

This problem can be solved using the standard multiplier class. Counter:from collections import Counter lst1 = ['1', '2' , '3' , '4'] lst2 = ['123', '234' , '345' , '334'] base = Counter(lst1) result = [s for s in lst2 if not (Counter(s) - base)] Condition not (Counter(s) - base) checks what's multiplying. s no more elements than base

As a sign-off to monotonically departing members, a number of errors do not exceed the last abandoned member. It's about accuracy.Then consider the attitude of the neighbouring members of a number. Next, the cumulative cycle: we list a new, add to the sum, and we check whether it is less than the intended accuracy.Write. When you write anything but a mission, we'll talk about your decision. ♪ ♪P.S. Well, if you've written, you can fix it now. Every dick doesn't need to be found from scratch. consider the attitude of the neighbouring members♪ The next member is simply multiplied by the previous member. -x^2 and sharing (n+1)(n+2)♪ So much easier and faster.And that's what happens (I'm making a mistake right in the program, and I just think a table of different meanings, and I'm comparing the "real" sinus:#include <iostream> #include <iomanip> #include <cmath> using namespace std; double series(double x, double eps) { double sum = x, term = x; int n = 1; while(abs(term) > eps) { term = -xx/(n+1)/(n+2); n += 2; sum += term; } return sum; } const double eps = 1e-8; int main() { for(double x = 0.0; x < 6.3; x += 0.2) { cout << setw(8) << x << " " << setw(10) << series(x,eps) << " " << setw(10) << sin(x) << endl; } }

You're out of the area for the Arctic. [-pi/2, pi/2]:In [83]: arr = np.arange(0.7, 2.2, 0.3) In [84]: arr Out[84]: array([ 0.7, 1. , 1.3, 1.6, 1.9, 2.2]) In [85]: x = 1.9 In [86]: math.acos(x * 0.48 * x) ValueError Traceback (most recent call last) <ipython-input-86-116284452697> in <module>() ----> 1 math.acos(x * 0.48 * x) ValueError: math domain error Verification:In [90]: x * 0.48 * x Out[90]: 1.7327999999999997 In [91]: x * 0.48 * x <= math.pi/2 Out[91]: False In fact, since you're already using NumPy, I'd advise you to use ventilated functions instead of cycles:In [99]: def func_vect(x): ...: if not isinstance(x, (np.ndarray, np.generic)): ...: a = np.array(x) ...: else: ...: a = x ...: return (0.48 ** 3 + np.sin(1.2 * a) / (np.arccos(a * 0.48 * a) + np.exp(-a / 2))) ...: In [100]: func_vect(arr) C:\Anaconda3\Scripts\ipython-script.py:6: RuntimeWarning: invalid value encountered in arccos Out[100]: array([ 0.47596058, 0.66647826, 0.98265387, nan, nan, nan]) In [101]: func_vect(zad2) Out[101]: array([ 0.23254206, 0.28922696, 0.39676013, 0.62461928, 0.94825303]) nan - symbol Not a NumberComparison of productivity for a set of 1,000 elements:In [107]: arr = np.random.rand(10**3) In [108]: l = arr.tolist() In [109]: len(arr) Out[109]: 1000 In [110]: len(l) Out[110]: 1000 In [111]: %%timeit ...: for n in l: ...: func(n) ...: 1000 loops, best of 3: 933 µs per loop In [112]: %timeit func_vect(arr) 10000 loops, best of 3: 54 µs per loop and now for a mass of 1,000.000 elements:In [113]: arr = np.random.rand(10**6) In [114]: l = arr.tolist() In [115]: len(arr) Out[115]: 1000000 In [116]: len(l) Out[116]: 1000000 In [117]: %%timeit ...: for n in l: ...: func(n) ...: 1 loop, best of 3: 949 ms per loop In [118]: %timeit func_vect(arr) 10 loops, best of 3: 59.4 ms per loop

Try this:Math.signum(number) * Math.round(Math.abs(number))

I understand class object. std::map<int, std::unique_ptr<MySet>> must be the owner of the indicators on MySet facilities, and therefore, when copying, it is necessary to create copies of the objects stored in the std::forward_list<std::shared_ptr<MySet>>For these purposes, either a normal cycle or standard algorithms, such as std::transform♪Below is a demonstration programme that shows how to use algorithms std::transform to copy the elements from one container to another. To illustrate the challenges of class designers and designers used as a basic element, I have included a consolation.#include <iostream> #include <memory> #include <forward_list> #include <map> #include <algorithm> #include <iterator> #include <utility> struct A { A() { std::cout << "A::A()" << std::endl; } A( const A & ) { std::cout << "A::A( const A & )" << std::endl; } ~A() { std::cout << "A::~A" << std::endl; } A & operator =( const A & ) { std::cout << "A::operator =( const A & )" << std::endl; return *this; } }; int main() { std::forward_list<std::shared_ptr<A>> lst; lst.push_front( std::shared_ptr<A>( new A ) ); std::map&lt;int, std::unique_ptr&lt;A&gt;&gt; m; std::transform( lst.begin(), lst.end(), std::inserter( m, m.end() ), []( auto p ) { return std::make_pair( 1, std::unique_ptr&lt;A&gt;( new A( *p.get() ) ) ); } ); return 0; } The withdrawal will be:A::A() A::A( const A & ) A::~A A::~A

I don't know what answer I wanted to hear from you at the interview, and I don't think a hundred percent of the right criteria can be.My opinion is that we need to catch an exception where You know what to do with him.♪I'll explain.Let's say you have a file opening function, there's no file, and she's throwing an exception. What do we do at this point?This is an important operation, without information from the file, you can't go on, so you need to inform the user and finish the program? Or is this a configuration file that's missing at the beginning of the program, and it's gonna need to be created with default data?You don't know that in the file opening. So you don't have to catch an exception, let him. Flying. to a higher level. Now, at the level of the larger logic that started reading the configuration, it's quite possible to have an exception when the file opens, catch it and just create a default configuration.This one-tier arrangement might be too simple, and you're gonna have to repack the exception by adding meaning to it. For example, when reading the number of the line, an exception was made because of a lack of format. You don't know at this point whether this problem is fatal, and you just skip the exception. The higher-level logic knows that there is a read-up of configuration data that somehow ended with the exception. At this point, the programme &apos; s logic has the opportunity to resolve that the problem cannot be ignored, and it leaves a higher-level exception, which means that &quot; the configuration has ended accidentally &quot; . This exception, in turn, captures the top-level business logic that reports the loss of the configuration file and re-establishs it.In any case, premature out-of- exceptions at too &quot; internal &quot; levels are harmful, because the programme at such a point usually cannot do anything reasonable.

There are several approaches to this task. But all of them can be divided into two main cases: this is an approach in the spirit of language C, when you need to create a new symbol mass for the building, and a second approach in the spirit of C++ when you deal with class objects. std::string♪Language approach C#include <iostream> #include <cstring> int main() { const char *s1 = ">< ><"; const char *s2 = "(\/)O_O(\/)"; char c = '<'; size_t n1 = std::strlen( s1 ); size_t n2 = std::strlen( s2 ); size_t k = 0; for ( const char *p = s1; ( p = std::strchr( p, c ) ) != nullptr; ++p ) { ++k; } char *result = new char[ n1 + k * n2 + 1 ]; char *p = result; const char *q = s1; do { if ( *q == c ) { memcpy( p, s2, n2 ); p += n2; } *p++ = *q; } while ( *q++ ); std::cout &lt;&lt; s1 &lt;&lt; std::endl; std::cout &lt;&lt; s2 &lt;&lt; std::endl; std::cout &lt;&lt; result &lt;&lt; std::endl; delete [] result; return 0; } Programme withdrawal:>< >< (/)O_O(/) >(/)O_O(/)< >(/)O_O(/)< C++ approach#include <iostream> #include <algorithm> #include <string> #include <cstring> int main() { std::string s1( ">< ><" ); const char *s2 = "(\/)O_O(\/)"; char c = '<'; std::cout &lt;&lt; s1 &lt;&lt; std::endl; size_t n2 = std::strlen( s2 ); auto k = std::count( s1.begin(), s1.end(), c ); s1.reserve( s1.size() + k * n2 ); for ( std::string::size_type pos = 0; ( pos = s1.find( c, pos ) ) != std::string::npos; pos += n2 + 1 ) { s1.insert( pos, s2 ); } std::cout &lt;&lt; s2 &lt;&lt; std::endl; std::cout &lt;&lt; s1 &lt;&lt; std::endl; return 0; } Programme withdrawal:>< >< (/)O_O(/) >(/)O_O(/)< >(/)O_O(/)< In this case, the reference line itself can be changed. s1♪

file is a heterator over the lines in Pitton. The specificity of the heterans that they're spending on reading, so the lines won't be read twice:from itertools import takewhile for line in file: if line.startswith("ip access-list extended"): access_list = ''.join(takewhile(lambda line: line.strip() != "exit", file)) This code reads a line-up file until the access-list block meets. Then all the lines until the line is equal. exit No meeting is counted as belonging to the current access-list block. The cycle then goes on and reads the remaining blocks before the end of the file. If the file is small, all access-list blocks can be accessed regularly:import re text = file.read() access_lists = re.findall(r"ip access-list extended\s+(.?)\s+^\sexit\s*$", text, flags=re.DOTALL | re.MULTILINE) Output for introduction:['"test" \n строка\n строка', '"test2" \n строка\n строка', '"test3" \n строка\n строка']

As you do, you can't do it. You're trying to greedly add elements to a smaller list. Simple example: 5 4 3 3. You'll put 5 and 4 on different lists, and it'll never happen again. This is a classic backpack task. It is addressed either through dynamic programming (the elements are reasonably small, the sum up to a million-10 e.g.) or by some kind of wind and boundary method (the number of cells within 20-30). In other cases, in reasonable time/memorial, you will not decide.You need to figure out the whole list first, then the pseudocod is like that. I'm guessing only the positive elements, if there's any negatives, you need to make some modifications.массив предыдущий инициализировать -1 предыдущий[0] = 0 цикл по списку val - текущий элемент списка цикл i от суммы списка/2 до val если предыдущий[i] = -1 и предыдущий[i-val] != -1 то предыдущий[i] = val //получение ответа Если предыдущий[sum/2] = -1 то выйти Текущий = sum/2 Пока текущий != 0 Вывести предыдущий[текущий] текущий = текущий - предыдущий[текущий] Example of implementation:def gen_left(numbers): K = sum(numbers) prev = [-1] * (K // 2 + 1) prev[0] = 0 for val in numbers: for i in range(K // 2, val-1, -1): # K//2..val inclusive if prev[i] == -1 and prev[i - val] != -1: prev[i] = val if prev[K//2] == -1: raise ValueError curr = K // 2 while curr > 0: yield prev[curr] curr -= prev[curr] def partition_equal_sums(numbers): left = list(gen_left(numbers)) right = list(numbers) for item in left: # O(n**2) right.remove(item) if sum(right) != sum(left): raise ValueError return left, right

Classic solution using a stack that retains Types (unbalanced) of opening brackets:For each symbol in the text check if it's opening If yes, add in the stack the type of brackets (angular/round/read) If not, check whether the symbol is a closing bracket. If the last added opening bracket is the same, I'll take her out of the steak. Otherwise, finish the algorithm of Snyden with the wrong bracket. To continue until the end of the text and if the stack is empty, the text contains only the correct brackets. On Pitone 3:def is_balanced(text, brackets="〈〉()[]{}"): opening, closing = brackets[::2], brackets[1::2] stack = [] # keep track of opening brackets types for character in text: if character in opening: # bracket stack.append(opening.index(character)) elif character in closing: # bracket if stack and stack[-1] == closing.index(character): stack.pop() # remove the matched pair else: return False # unbalanced (no corresponding opening bracket) or # unmatched (different type) closing bracket return (not stack) # no unbalanced brackets In this case, the type of brackets (correct/quadrant/read) is presented in the index opening a list containing all brackets. closing contains brackets of the same types on the same indices.Example:>>> is_balanced('скобки 〈 п{р}авильно (вло[ж]ены)〉') True >>> is_balanced('скобки НЕ 〈 пр(авильно вложены〉)') False

The encrypted message (i.e., the bikes) can be online, stored in the file, etc. in different ways - Like a set of bikes, it's easy. For example, in the form of a binary file, basic clear flows are primarily geared towards the introduction and release of bait flows.LinesString) There may also be two different approaches in principle. to receive the line from the bayt area by the constructor of the line String(byte[] data) and then, before decoding, convert the line into a bayt mass by a method getBytes() - it's simple, but the lines will be unreadable, and I'm not sure all the possible meanings of the bikes can be transmitted in such a way (to be checked) Convert the bayt area into the reading line, recording the numerals (type) "01, 02, -05"And before deciphering this line as it is on the software heater, it's to divide one-by-line baytha into a substrate and to extract the meaning of the bayt from each of these submarines. In addition, there should be clear separations between the Whites, since "1234" - mixed-- {12, 34} or {123, 4}? Breaking lines by divider can be done by method split() Class Stringand convert the line into a white by a static method Byte.parseByte(String s)♪

How can we compare two objects if they have a few submissions? For example, are two rational numbers 4/10 and 12/30 equal? Whether the roots of equations match x2+2x+4 and 5x2+10x+20? Are many [1; 2; 3] and [1; 3; 2]?If the target is &quot; forehead &quot; , the objects do not coincide, but in reality 4/10 == sync, corrected by elderman == @elder_man It's not right.In order to meet such challenges, the objects lead to a uniformity, often referred to as normalAnd the ghost... normalization♪ Drobs are down, all square equation coefficients are divided by factor x2and the masses are sorted.Sometimes different ways of normalization are possible. If the numbers are small, instead of the mass, you can keep them in the battle. For example, for many numbers between 0 and 31, one 30-thirty-thirty-thirty-thirty-thirty-thirty-thirty-thirty-thirty-thirty-thirty-thirty-thirty-thirty-thirty-two could be stored, with the appropriate bats installed.Then the comparison of multiples will lead to two whole numbers. But if our numbers can be arbitrary, the battle mass may be too large. In this case, the sorting works well. Comparison of the two fragmented masses is simple, in contrast to the temporary complexity of O(N). It's not very fast, but it's much faster than a double comparison of the sorted masses with the complexity of O(N)2)

As an option:#include <map> #include <iostream> using namespace std; int main() { map<int,int> M; int n, count = 0; cin >> n; for (int i = 0; i &lt; n; i++) { int x; cin &gt;&gt; x; M[x]++; } for(auto x: M) { if (x.second &gt; 1) // Эту строку можно и выкинуть :) count += x.second/2; } cout &lt;&lt; count; return 0; }

del- The design allows the use of cuts:del L[N-1::N] In general, with a more complex criterion for disposal, a new list could be created that contains only the elements to be retained and replaced by the contents of the reference list:L[:] = [x for i, x in enumerate(L, start=1) if i % N]