{"id":2827,"date":"2020-11-21T18:33:11","date_gmt":"2020-11-21T18:33:11","guid":{"rendered":"https:\/\/idiagress.com\/vinaaypatil\/?p=2827"},"modified":"2023-10-29T09:16:37","modified_gmt":"2023-10-29T09:16:37","slug":"1-8-comparing-lists-using-functions","status":"publish","type":"post","link":"https:\/\/idiagress.com\/vinaaypatil\/2020\/11\/21\/1-8-comparing-lists-using-functions\/","title":{"rendered":"1.8 Comparing Lists using Functions"},"content":{"rendered":"\n

Moving on from our exploration of quadratic equation roots, we are about to dive into another captivating realm of problem-solving. <\/p>\n\n\n\n

Yet, before we do, it’s essential to acknowledge a limitation in our bisection program. Our current implementation works well for cases with one positive and one negative root. <\/p>\n\n\n\n

However, it falls short when both roots share the same sign, be it positive or negative. To illustrate, let’s consider the equation (x+2)(x+5), which expands to x^2 + 7x + 10. In this scenario, the roots are x = -2 and x = -5, both negative. Unfortunately, our current program captures only one of these two roots.<\/p>\n\n\n\n

<\/div>\n\n\n
\n
\"\"<\/a><\/figure>\n<\/div>\n\n\n
<\/div>\n\n\n\n

From the Output, it is clear the program needs work. Maybe you can work and try to improve it.<\/p>\n\n\n\n

For now, let’s move to Factorization<\/p>\n\n\n\n

\n\n\n\n

A. Prime Factorization<\/strong><\/p>\n\n\n\n

In mathematics, factors of a number are those values that, when multiplied together, yield the original number. For instance, in the case of 24, we can express it as the product of 12 and 2. Here, 12 and 2 are factors of 24.<\/p>\n\n\n\n

Nonetheless, in mathematical pursuits, our primary concern lies in discerning the prime factors of a number. Prime factors are those indivisible components of a number that are prime themselves. For example, when we delve into the prime factors of 24, we can decompose it into 2, 2, 2, and 3\u2014a collection of purely prime factors.<\/p>\n\n\n\n

Let’s now delve into crafting an algorithm for the precise determination of these prime factors.<\/p>\n\n\n\n

<\/div>\n\n\n
\n
\"\"<\/a><\/figure>\n<\/div>\n\n\n
<\/div>\n\n\n
\n
\"\"<\/figure>\n<\/div>\n\n\n
<\/div>\n\n\n\n
\n
<\/div>\n\n\n\n
\n

Here’s a step-by-step approach to finding the prime factors of a number:<\/p>\n\n\n\n

    \n
  1. Start with the number you want to find the prime factors of (let’s call it n<\/code>).<\/li>\n\n\n\n
  2. Initialize an empty list to store the prime factors.<\/li>\n\n\n\n
  3. Begin with the smallest prime number, which is 2.<\/li>\n\n\n\n
  4. Check if n<\/code> is divisible by 2. If it is, add 2 to the list of prime factors and divide n<\/code> by 2 repeatedly until it is no longer divisible by 2.<\/li>\n\n\n\n
  5. Move on to the next prime number, which is 3, and check if n<\/code> is divisible by 3. If it is, add 3 to the list of prime factors and divide n<\/code> by 3 repeatedly until it is no longer divisible by 3.<\/li>\n\n\n\n
  6. Continue this process, incrementing the prime number each time, and checking if n<\/code> is divisible by the current prime number. If it is, add the prime factor to the list and divide n<\/code> by that prime number as many times as possible.<\/li>\n\n\n\n
  7. Repeat steps 4-6 until you have exhausted all prime numbers less than or equal to the square root of n<\/code>. After this, if n<\/code> is greater than 1, it means that n<\/code> itself is a prime factor.<\/li>\n\n\n\n
  8. You now have a list of prime factors that, when multiplied together, will give you the original number n<\/code>.<\/li>\n<\/ol>\n<\/div>\n\n\n\n
    <\/div>\n<\/div>\n\n\n\n
    <\/div>\n\n\n\n

    The fundamental idea behind prime factorization is to progress through the sequence of prime numbers (2, 3, 5, 7, 11, and so on) until the quotient becomes ‘1.’<\/p>\n\n\n\n

    Now, you might wonder if it’s necessary to maintain a list of all prime numbers. Interestingly, besides ‘2,’ all prime numbers are ‘odd.’ <\/mark><\/strong>Therefore, a more efficient approach is to simply advance through the list of odd numbers. This simplifies the programming.<\/p>\n\n\n\n

    But what about factors that are ‘odd’ yet not ‘prime’? For instance, consider 27, which can be expressed as 9 multiplied by 3. The factor ‘9’ in this case is ‘not a prime’ number. The primary goal, however, is to isolate prime numbers.<\/p>\n\n\n\n

    Here’s a crucial point to grasp: By starting with a lower odd number (e.g., 3) and continually dividing until reaching a non-zero remainder, we effectively eliminate non-prime factors before encountering a non-prime number.<\/p>\n\n\n\n

    To illustrate, let’s take the number 99 as an example. Our concern is the possibility of capturing a non-prime factor. In this instance, 99 can be factored into 9 and 11. But what if ‘9’ is mistakenly identified as a factor?<\/p>\n\n\n\n

    <\/div>\n\n\n
    \n
    \"\"<\/a><\/figure>\n<\/div>\n\n\n
    <\/div>\n\n\n\n

    We can see that the factor of ‘9’ gets reduced before we reach ‘9’ as a divisor. Thus, it does not get captured as a factor<\/p>\n\n\n\n

    This greatly simplifies our program. We don’t need to maintain a list of prime numbers; we can move upwards without worrying about non-prime numbers getting captured as factors.<\/p>\n\n\n\n

    <\/div>\n\n\n\n

    Flow of the program<\/h4>\n\n\n\n
    Step No<\/b><\/span><\/td> <\/td>Command<\/b><\/span><\/td>Interpretation<\/b><\/span><\/td>Paramater Value<\/b><\/span><\/td><\/tr>
    1<\/span><\/td> <\/td>_number = <\/span>int<\/span>(<\/span>input<\/span>(<\/span>“Enter the number for factorization:\u201d<\/span>)) <\/span><\/td>Ask user to input value of  <\/span>number for factorization<\/span><\/td>_number = 132<\/span><\/td><\/tr>
    2<\/span><\/td> <\/td>while<\/span> _number % 2== <\/span>0<\/span>:<\/span><\/td>2 is a factor till remainder is zero<\/span><\/td>132 % 2 = 0<\/span>

    TRUE<\/mark><\/strong><\/span><\/p> <\/td><\/tr>

     <\/td>2.L.1<\/span><\/td>print<\/span>(<\/span>\u201c2 is a factor\u201d<\/span>)<\/span><\/td> <\/td> <\/td><\/tr>
     <\/td>2.L.2<\/span><\/td>_number = _number \/ 2<\/span><\/td>Get quotient<\/span><\/td>_number = 132\/2<\/span>\n

    _number = 66<\/span><\/p>\n<\/td><\/tr>

     <\/td> <\/td>while<\/span> _number % 2== <\/span>0<\/span>:<\/span><\/td>2 is a factor till remainder is zero<\/span><\/td>66 % 2 = 0<\/span>

    TRUE<\/mark><\/strong><\/span><\/p> <\/td><\/tr>

     <\/td>2.L.1<\/span><\/td>print<\/span>(<\/span>\u201c2 is a factor\u201d<\/span>)<\/span><\/td> <\/td> <\/td><\/tr>
     <\/td>2.L.2<\/span><\/td>_number = _number \/ 2<\/span><\/td>Get quotient<\/span><\/td>_number = 66 \/2<\/span>\n

    _number = 33<\/span><\/p>\n<\/td><\/tr>

     <\/td> <\/td>while<\/span> _number % 2== <\/span>0<\/span>:<\/span><\/td>2 is a factor till remainder is zero<\/span><\/td>33 % 2 = 0<\/span>

    FALSE<\/strong><\/mark><\/span><\/p> <\/td><\/tr>

     <\/td> <\/td> <\/td>EXIT WHILE LOOP<\/strong><\/mark><\/span><\/td> <\/td><\/tr>
    3<\/span><\/td> <\/td>for<\/span> _fac <\/span>in<\/span> range<\/span>(<\/span>3<\/span>, _number, <\/span>2<\/span>):<\/span><\/td>begin \u2018for\u2019 loop to scan for \u2018odd\u2019 factors <\/span>NOTE: We are jumping range by ‘2’, which means we will go, 3, 5, 7, i.e ODD numbers<\/span>. <\/strong><\/mark>
    <\/td>    		_fac = 3<\/span>\n

    _number = 33<\/span><\/p>\n<\/td><\/tr>

     <\/td>3.L.1<\/span><\/td>while<\/span> _number % _fac== <\/span>0<\/span>:<\/span><\/td>_fac is a factor till remainder is zero<\/span><\/td>33 % 3 = 0<\/span>

    TRUE<\/strong><\/mark><\/span><\/p> <\/td><\/tr>

     <\/td>3.L.2<\/span><\/td>print<\/span>(_fac, <\/span>\u201c is a factor\u201d<\/span>)<\/span><\/td> <\/td> <\/td><\/tr>
     <\/td>3.L.3<\/span><\/td>_number = _number \/ _fac<\/span><\/td>Get quotient<\/span><\/td>_number = 33 \/3<\/span>\n

    _number = 11<\/span><\/p>\n<\/td><\/tr>

     <\/td>3.L.1<\/span><\/td>while<\/span> _number % fac == <\/span>0<\/span>:<\/span><\/td>_fac is a factor till remainder is zero<\/span><\/td>11 % 3 = 0<\/span>

    FALSE<\/mark><\/strong><\/span><\/p> <\/td><\/tr>

     <\/td> <\/td> <\/td>EXIT WHILE LOOP<\/mark><\/strong><\/span><\/td> <\/td><\/tr>
     <\/td> <\/td>_fac <\/span>in<\/span> range<\/span>(<\/span>3<\/span>, _number, <\/span>2<\/span>)<\/span><\/td>_fac = _fac + 2<\/span>\n

    range increment<\/span><\/p>\n<\/td>

    		_fac = 3 + 2<\/span>\n

    _fac = 5<\/span><\/p>\n<\/td><\/tr>

     <\/td>3.L.1<\/span><\/td>while<\/span> _number % fac == <\/span>0<\/span>:<\/span><\/td>_fac is a factor till remainder is zero<\/span><\/td>11 % 5 = 0<\/span>

    FALSE<\/mark><\/strong><\/span><\/p> <\/td><\/tr>

     <\/td> <\/td> <\/td>EXIT WHILE LOOP<\/mark><\/strong><\/span><\/td> <\/td><\/tr>
     <\/td> <\/td>_fac <\/span>in<\/span> range<\/span>(<\/span>3<\/span>, _number, <\/span>2<\/span>)<\/span><\/td>_fac = _fac + 2<\/span>\n

    range increment<\/span><\/p>\n<\/td>

    		_fac = 5 + 2<\/span>\n

    _fac = 7<\/span><\/p>\n<\/td><\/tr>

     <\/td>3.L.1<\/span><\/td>while<\/span> _number % fac == <\/span>0<\/span>:<\/span><\/td>_fac is a factor till remainder is zero<\/span><\/td>11 % 7 = 0<\/span>

    FALSE<\/mark><\/strong><\/span><\/p> <\/td><\/tr>

     <\/td> <\/td> <\/td>EXIT WHILE LOOP<\/strong><\/mark><\/span><\/td> <\/td><\/tr>
     <\/td> <\/td>_fac <\/span>in<\/span> range<\/span>(<\/span>3<\/span>, _number, <\/span>2<\/span>)<\/span><\/td>_fac = _fac + 2<\/span>\n

    range increment<\/span><\/p>\n<\/td>

    		_fac = 7 + 2<\/span>\n

    _fac = 9<\/span><\/p>\n<\/td><\/tr>

     <\/td>3.L.1<\/span><\/td>while<\/span> _number % fac == <\/span>0<\/span>:<\/span><\/td>_fac is a factor till remainder is zero<\/span><\/td>11 % 9 = 0<\/span>

    FALSE<\/mark><\/strong><\/span><\/p> <\/td><\/tr>

     <\/td> <\/td> <\/td>EXIT WHILE LOOP<\/mark><\/strong><\/span><\/td> <\/td><\/tr>
     <\/td> <\/td>_fac <\/span>in<\/span> range<\/span>(<\/span>3<\/span>, _number, <\/span>2<\/span>)<\/span><\/td>_fac = _fac + 2<\/span>\n

    range increment<\/span><\/p>\n<\/td>

    		_fac = 9 + 2<\/span>\n

    _fac = 11<\/span><\/p>\n<\/td><\/tr>

     <\/td>3.L.1<\/span><\/td>while<\/span> _number % _fac== <\/span>0<\/span>:<\/span><\/td>_fac is a factor till remainder is zero<\/span><\/td>11 % 11 = 0<\/span>\n

    TRUE<\/span><\/p>\n<\/td><\/tr>

     <\/td>3.L.2<\/span><\/td>print<\/span>(_fac, <\/span>\u201c is a factor\u201d<\/span>)<\/span><\/td> <\/td> <\/td><\/tr>
     <\/td>3.L.3<\/span><\/td>_number = _number \/ _fac<\/span><\/td>Get quotient<\/span><\/td>_number = 11 \/3<\/span>\n

    _number = 1<\/span><\/p>\n<\/td><\/tr>

     <\/td>3.L.4<\/span><\/td>fac <\/span>in<\/span> range<\/span>(<\/span>3<\/span>, _number, <\/span>2<\/span>)<\/span><\/td>FINISH program as _fac is beyond range<\/mark><\/strong><\/span><\/td>_fac > _number<\/span>\n

    11 > 1<\/span><\/p>\n<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

    <\/div>\n\n\n\n

    Based on the above algorithm the program (basic_factors.py) is as follows: <\/span><\/p>\n\n\n\n

    <\/div>\n\n\n\n
    basic_factors.py<\/b><\/span><\/td><\/tr>
    _number = <\/span>int<\/span>(<\/span>input<\/span>(<\/span>“Enter number for Factorization: “<\/span>))
      <\/span>
    <\/span>while<\/span> _number % <\/span>2<\/span> == <\/span>0<\/span>:
        <\/span><\/span>print<\/span>(<\/span>“2 is a factor “<\/span>)
        <\/span>_number = _number \/<\/span>2
    <\/span>   <\/span>
    <\/span>for<\/span> _fac <\/span>in<\/span> range<\/span> (<\/span>3<\/span>, _number, <\/span>2<\/span>):
        <\/span><\/span>while<\/span> _number % _fac ==<\/span>0<\/span>:
            <\/span><\/span>print<\/span>(_fac, <\/span>” is a factor”<\/span>)
            <\/span>_number = _number\/ _fac <\/span>
    <\/span><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
    <\/div>\n\n\n\n

    The output of the program is as follows.<\/p>\n\n\n\n

    <\/div>\n\n\n
    \n
    \"\"<\/a><\/figure>\n<\/div>\n\n\n
    <\/div>\n\n\n\n

    The output successfully executes the code for the first ‘while’ loop, identifying ‘2’ as a factor. However, a challenge arises when the program enters the ‘for’ loop, resulting in an error related to a ‘float’ object.<\/p>\n\n\n\n

    This issue stems from the fact that during the process of dividing a number, the data type can transition to ‘float.’ For instance, when we execute the operation _number = _number \/ 2<\/code>, _number<\/code> becomes a ‘float’ data type.<\/mark><\/strong><\/p>\n\n\n\n

    The problem arises when we subsequently pass this variable, which is now a ‘float,’ into the ‘range’ function. It’s crucial to note that the ‘range’ function exclusively accepts ‘integer’ variables<\/mark><\/strong>, and this discrepancy leads to the error..<\/p>\n\n\n\n

    To circumvent this issue, we need to reconvert the variable back to an ‘integer’ before using it in the ‘for’ loop. We can achieve this by applying the following modification:<\/p>\n\n\n\n

    for _fac inrange (3, int(_number), 2):<\/code><\/pre>\n\n\n\n
    This alteration ensures that the data type of _number<\/code> remains as an ‘integer’ within the ‘for’ loop, preventing any ‘float’ object errors. This refined approach maintains data type consistency and facilitates accurate prime factorization.\u00a0<\/span><\/p>\n\n\n\n
    <\/div>\n\n\n
    \n
    \"\"<\/a><\/figure>\n<\/div>\n\n\n
    <\/div>\n\n\n\n
    \n\n\n\n
    B. Comparison of Factors<\/b><\/h3>\n\n\n\n
    In our existing program, we are proficient at identifying factors of a given number. However, what’s currently missing is the mechanism to store these factors. Since our objective is to collect all the factors in one organized place, the most practical approach is to employ a ‘list.’<\/p>\n\n\n\n
    We can leverage the append()<\/code> function to conveniently add identified factors to a list. To achieve this, we will encapsulate the steps for calculating factors within a dedicated function and return a list containing all the factors for a specified number.<\/p>\n\n\n\n
    The program, titled ‘list_factors.py<\/mark><\/strong>,’ is structured as follows:<\/p>\n\n\n\n
    list_factors.py<\/b><\/span><\/td><\/tr>
    def<\/span> factorize_number<\/span>(_number):
        <\/span><\/span>“”” function to calculate factors of a number “””
    <\/span>    <\/span>_factors = []
           <\/span>
        <\/span><\/span>while<\/span> _number % <\/span>2<\/span> == <\/span>0<\/span>:
            <\/span>_factors.<\/span>append<\/span>(<\/span>2<\/span>)
            <\/span>_number = _number\/<\/span>2
    <\/span>     <\/span>
        <\/span><\/span>for<\/span> _fac <\/span>in<\/span> range<\/span>(<\/span>3<\/span>, <\/span>int<\/span>(_number), <\/span>2<\/span>):
            <\/span><\/span>while<\/span> _number % _fac == <\/span>0<\/span>:
                <\/span>_factors.<\/span>append<\/span>(_fac)
                <\/span>_number = _number\/_fac
         <\/span>
        <\/span><\/span>return<\/span> _factors
       <\/span>
       <\/span>
    _a = <\/span>int<\/span>(<\/span>input<\/span>(<\/span>“Enter number for Factorization: “<\/span>))
    _factors_a = <\/span>factorize_number<\/span>(_a)
       <\/span>
    <\/span>print<\/span>(<\/span>“The factors of “<\/span>, _a, <\/span>” are “<\/span>, _factors_a)
    <\/span><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
    <\/div>\n\n\n\n
    We’ve carried out a straightforward replacement in the code. Wherever in our previous program, there was a print(\"is a factor\")<\/code>, we’ve replaced it with _factors.append<\/code> to add the identified factor to a list. The result is a neatly organized list of factors.\u00a0<\/span><\/p>\n\n\n\n
    <\/div>\n\n\n
    \n
    \"\"<\/a><\/figure>\n<\/div>\n\n\n
    <\/div>\n\n\n\n
    \n\n\n\n
    The next part will be to factorize two numbers, so that we can calculate the H.C.F. (Highest Common Factor).<\/p>\n\n\n\n
    Let\u2019s see a sample HCF calculation.<\/p>\n\n\n\n
    <\/div>\n\n\n\n
    Calculate HCF of the numbers 60 and 82<\/p>\n\n\n\n
    Factors of 60      are     [ 2 , 2 , 3 , 5 ]<\/p>\n\n\n\n
    Factors of 84      are     [ 2 , 2,  <\/span>3 , 7 ]<\/p>\n\n\n\n
    Comparing the factors and highlighting common factors<\/p>\n\n\n\n
    [ 2, 2, 3<\/span> <\/strong>, 5 ]     <\/span>[ 2, 2, 3<\/span><\/strong> , 7 ]<\/p>\n\n\n\n
    Common factors     are     [ 2 , 2 , 3 ]<\/p>\n\n\n\n
    HCF is multiplication of common factors     = 2 \u2022 2 \u2022 3      = 12<\/p>\n\n\n\n
    <\/div>\n\n\n\n
    Our program excels at calculating the factors and storing them in a list. The next essential task is to compare these two lists and construct a new list comprising all the common factors.<\/p>\n\n\n\n
    To accomplish this comparison, we iterate through the elements of list A and, for each element, check against every other element in list B. If two elements match, we add that element to a common list and ensure it isn’t considered again in subsequent comparisons. The logic for this comparison can be expressed  as follows:<\/p>\n\n\n\n
    <\/div>\n\n\n\n
     <\/td> <\/td> <\/td> <\/td><\/tr>
    For every                                      <\/span><\/b><\/span><\/td>element <\/b><\/span><\/td>in <\/b><\/span><\/td>list A,           <\/span><\/b><\/span><\/td><\/tr>
    we want to check every<\/b><\/span><\/td>other element <\/b><\/span><\/td>in<\/b><\/span><\/td>list B,<\/b><\/span><\/td><\/tr>
    and<\/b><\/span><\/td>if the two elements are equal<\/b><\/span><\/td>add element in <\/b><\/span><\/td>a     <\/span>Common list<\/b><\/span><\/td><\/tr>
    Plus,<\/b><\/span><\/td>Don\u2019t consider the element again <\/b><\/span><\/td>in the<\/b><\/span><\/td>next comparison<\/b><\/span><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
    <\/div>\n\n\n\n
    Code wise we can write the logic as:<\/p>\n\n\n\n
    <\/div>\n\n\n\n
    Appending function for Factors<\/b><\/span><\/td><\/tr>
       <\/span><\/span>for<\/span> element <\/span>in<\/span> _fa:
            <\/span><\/span>for<\/span> other_element <\/span>in<\/span> _fb:
                <\/span><\/span>if<\/span> element == other_element:
                    <\/span>_common.<\/span>append<\/span>(element)
                    <\/span>_fb.<\/span>remove<\/span>(other_element)
                     <\/span>
       <\/span><\/span>return<\/span> _common<\/span>
      <\/span><\/span><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
    <\/div>\n\n\n\n
    We now need to code the above code for comparison as a function defined to compare two lists.<\/p>\n\n\n\n
    The program (hcf.py) is as follows. <\/span><\/p>\n\n\n\n
    <\/div>\n\n\n
    \n
    \"\"<\/a><\/figure>\n<\/div>\n\n\n
    <\/div>\n\n\n
    \n
    \"\"<\/a><\/figure>\n<\/div>\n\n\n
    <\/div>\n\n\n\n
    The output is<\/p>\n\n\n\n
    <\/div>\n\n\n
    \n
    \"\"<\/a><\/figure>\n<\/div>\n\n\n
    <\/div>\n\n\n\n
    \n\n\n\n
    C. Immutable and Mutable <\/span><\/b><\/h2>\n\n\n\n
    Before we delve into our program and calculate the HCF by multiplying the common factors, it’s crucial to grasp a fundamental concept about lists and other data types: the distinction between mutable and immutable objects. To gain a clearer understanding, you can run your program in Thonny or insert print commands in the Atom file to examine the final values of variables.<\/p>\n\n\n\n
    If you scrutinize the final values of variables, you’ll observe that the list _factors_b<\/code> has been modified from [2, 2, 3, 7]<\/code> to [7]<\/code>. This modification takes place even after we saved _factors_b<\/code> in _fb<\/code> before passing the lists into the functions. Both lists are being altered within the function.<\/p>\n\n\n\n
    <\/div>\n\n\n
    \n
    \"\"<\/a><\/figure>\n<\/div>\n\n\n
    <\/div>\n\n\n\n
    This behavior can be attributed to the fact that, in Python, everything is an object, and objects are categorized into two groups: mutable and immutable.<\/p>\n\n\n\n