Find the value of k. Round answer and then write it in scientific method. K= 18,771.336²/140.608³?

Answer 1

1/101 is then added, the result is 10001/999900. The size of arbitrary-precision numbers is limited in practice by the total storage available, the variables used to index the digit strings, and computation time. A 32-bit operating system may limit available storage to less than 4 GB. A programming language using 32-bit integers can only index 4 GB. If multiplication is done with a Θ {\displaystyle \Theta } (N2) algorithm, it would take on the order of 1012 steps to multiply two one-million-word numbers. Numerous algorithms have been developed to efficiently perform arithmetic operations on numbers stored with arbitrary precision. In particular, supposing that N digits are employed, algorithms have been designed to minimize the asymptotic complexity for large N. The simplest algorithms are for addition and subtraction, where one simply adds or subtracts the digits in sequence, carrying as necessary, which yields an O(N) algorithm (see big O notation). Comparison is also very simple. Compare the high-order digits (or machine words) until a difference is found. Comparing the rest of the digits/words is not necessary. The worst case is Θ {\displaystyle \Theta } (N), but usually it will go much faster. For multiplication, the most straightforward algorithms used for multiplying numbers by hand (as taught in primary school) require Θ {\displaystyle \Theta } (N2) operations, but multiplication algorithms that achieve O(N log(N) log(log(N))) complexity have been devised, such as the Schönhage–Strassen algorithm, based on fast Fourier transforms, and there are also algorithms with slightly worse complexity but with sometimes superior real-world performance for smaller N. The Karatsuba multiplication is such an algorithm. For division, see division algorithm. For a list of algorithms along with complexity estimates, see computational complexity of mathematical operations. For examples in x86 assembly, see external links. In some languages such as REXX, the precision of all calculations must be set before doing a calculation. Other languages, such as Python and Ruby extend the precision automatically to prevent overflow. The calculation of factorials can easily produce very large numbers. This is not a problem for their usage in many formulae (such as Taylor series) because they appear along with other terms, so that—given careful attention to the order of evaluation—intermediate calculation values are not troublesome. If approximate values of factorial numbers are desired, Stirling's approximation gives good results using floating-point arithmetic. The largest representable value for a fixed-size integer variable may be exceeded even for relatively small arguments as shown in the table below. Even floating-point numbers are soon outranged, so it may help to recast the calculations in terms of the logarithm of the number. But if exact values for large factorials are desired, then special software is required, as in the pseudocode that follows, which implements the classic algorithm to calculate 1, 1×2, 1×2×3, 1×2×3×4, etc. the successive factorial numbers. Constant Limit = 1000; % Sufficient digits. Constant Base = 10; % The base of the simulated arithmetic. Constant FactorialLimit = 365; % Target number to solve, 365! Array digit[1:Limit] of integer; % The big number. Integer carry,d; % Assistants during multiplication. Integer last,i; % Indices to the big number's digits. Array text[1:Limit] of character; % Scratchpad for the output. Constant tdigit[0:9] of character = ["0","1","2","3","4","5","6","7","8","9"]; BEGIN digit:=0; % Clear the whole array. digit[1]:=1; % The big number starts with 1, last:=1; % Its highest-order digit is number 1. for n:=1 to FactorialLimit do % Step through producing 1!, 2!, 3!, 4!, etc. carry:=0; % Start a multiply by n. for i:=1 to last do % Step along every digit. d:=digit[i]*n + carry; % The classic multiply. digit[i]:=d mod Base; % The low-order digit of the result. carry:=d div Base; % The carry to the next digit. next i; while carry > 0 % Store the carry in the big number. if last >= Limit then croak("Overflow!"); % If possible! last:=last + 1; % One more digit. digit[last]:=carry mod Base; % Placed. carry:=carry div Base; % The carry reduced. Wend % With n > Base, maybe > 1 digit extra. text:=" "; % Now prepare the output. for i:=1 to last do % Translate from binary to text. text[Limit - i + 1]:=tdigit[digit[i]]; % Reversing the order. next i; % Arabic numerals put the low order last. Print text," = ",n,"!"; % Print the result! next n; % On to the next factorial up. END; With the example in view, a number of details can be discussed. The most important is the choice of the representation of the big number. In this case, only integer values are required for digits, so an array of fixed-width integers is adequate. It is convenient to have successive elements of the array represent higher powers of the base. The second most important decision is in the choice of the base of arithmetic, here ten. There are many considerations. The scratchpad variable d must be able to hold the result of a single-digit multiply plus the carry from the prior digit's multiply. In base ten, a sixteen-bit integer is certainly adequate as it allows up to 32767. However, this example cheats, in that the value of n is not itself limited to a single digit