I am working on the file "Course 5/Neural machine translation with attention v4.ipynb".
The first task is:
You can also change these examples to test with your own examples. The next part will give you a better sense on what the attention mechanism is doing--i.e., what part of the input the network is paying attention to when generating a particular output character.
3 - Visualizing Attention (Optional / Ungraded)
Since the problem has a fixed output length of 10, it is also possible to carry out this task using 10 different softmax units to generate the 10 characters of the output. But one advantage of the attention model is that each part of the output (say the month) knows it needs to depend only on a small part of the input (the characters in the input giving the month). We can  visualize what part of the output is looking at what part of the input.
Consider the task of translating "Saturday 9 May 2018" to "2018-05-09". If we visualize the computed $\alpha^{\langle t, t' \rangle}$ we get this:

 Figure 8: Full Attention Map

Notice how the output ignores the "Saturday" portion of the input. None of the output timesteps are paying much attention to that portion of the input. We see also that 9 has been translated as 09 and May has been correctly translated into 05, with the output paying attention to the parts of the input it needs to to make the translation. The year mostly requires it to pay attention to the input's "18" in order to generate "2018."
3.1 - Getting the activations from the network
Lets now visualize the attention values in your network. We'll propagate an example through the network, then visualize the values of $\alpha^{\langle t, t' \rangle}$.
To figure out where the attention values are located, let's start by printing a summary of the model .
Can you write Python code for it?


I am working on the file "Course 5/Neural machine translation with attention v4.ipynb".
The first task is:
You now have:
- X: a processed version of the human readable dates in the training set, where each character is replaced by an index mapped to the character via human_vocab. Each date is further padded to $T_x$ values with a special character (< pad >). X.shape = (m, Tx)
- Y: a processed version of the machine readable dates in the training set, where each character is replaced by the index it is mapped to in machine_vocab. You should have Y.shape = (m, Ty).
- Xoh: one-hot version of X, the "1" entry's index is mapped to the character thanks to human_vocab. Xoh.shape = (m, Tx, len(human_vocab))
- Yoh: one-hot version of Y, the "1" entry's index is mapped to the character thanks to machine_vocab. Yoh.shape = (m, Tx, len(machine_vocab)). Here, len(machine_vocab) = 11 since there are 11 characters ('-' as well as 0-9).
Lets also look at some examples of preprocessed training examples. Feel free to play with index in the cell below to navigate the dataset and see how source/target dates are preprocessed.
Can you write Python code for it?

index = 0
print("Source date:", dataset[index][0])
print("Target date:", dataset[index][1])
print()
print("Source after preprocessing (indices):", X[index])
print("Target after preprocessing (indices):", Y[index])
print()
print("Source after preprocessing (one-hot):", Xoh[index])
print("Target after preprocessing (one-hot):", Yoh[index])


I am working on the file "Course 5/Neural machine translation with attention v4.ipynb".
The first task is:
You will be able to check the expected output of one_step_attention() after you've coded the model() function.
Exercise: Implement model() as explained in figure 2 and the text above. Again, we have defined global layers that will share weights to be used in model().
Can you write Python code for it?

n_a = 32
n_s = 64
post_activation_LSTM_cell = LSTM(n_s, return_state = True)
output_layer = Dense(len(machine_vocab), activation=softmax)


I am working on the file "Course 5/Neural machine translation with attention v4.ipynb".
The first task is:
You've loaded:
- dataset: a list of tuples of (human readable date, machine readable date)
- human_vocab: a python dictionary mapping all characters used in the human readable dates to an integer-valued index
- machine_vocab: a python dictionary mapping all characters used in machine readable dates to an integer-valued index. These indices are not necessarily consistent with human_vocab.
- inv_machine_vocab: the inverse dictionary of machine_vocab, mapping from indices back to characters.
Let's preprocess the data and map the raw text data into the index values. We will also use Tx=30 (which we assume is the maximum length of the human readable date; if we get a longer input, we would have to truncate it) and Ty=10 (since "YYYY-MM-DD" is 10 characters long).
Can you write Python code for it?

Tx = 30
Ty = 10
X, Y, Xoh, Yoh = preprocess_data(dataset, human_vocab, machine_vocab, Tx, Ty)

print("X.shape:", X.shape)
print("Y.shape:", Y.shape)
print("Xoh.shape:", Xoh.shape)
print("Yoh.shape:", Yoh.shape)


I am working on the file "Course 5/Operations on word vectors v2.ipynb".
The first task is:
As you can see, female first names tend to have a positive cosine similarity with our constructed vector $g$, while male first names tend to have a negative cosine similarity. This is not suprising, and the result seems acceptable.
But let's try with some other words.
Can you write Python code for it?

print('Other words and their similarities:')
word_list = ['lipstick', 'guns', 'science', 'arts', 'literature', 'warrior','doctor', 'tree', 'receptionist',
             'technology',  'fashion', 'teacher', 'engineer', 'pilot', 'computer', 'singer']
for w in word_list:
    print (w, cosine_similarity(word_to_vec_map[w], g))


I am working on the file "Course 5/Operations on word vectors v2.ipynb".
The first task is:
Do you notice anything surprising? It is astonishing how these results reflect certain unhealthy gender stereotypes. For example, "computer" is closer to "man" while "literature" is closer to "woman". Ouch!
We'll see below how to reduce the bias of these vectors, using an algorithm due to Boliukbasi et al., 2016. Note that some word pairs such as "actor"/"actress" or "grandmother"/"grandfather" should remain gender specific, while other words such as "receptionist" or "technology" should be neutralized, i.e. not be gender-related. You will have to treat these two type of words differently when debiasing.
3.1 - Neutralize bias for non-gender specific words
The figure below should help you visualize what neutralizing does. If you're using a 50-dimensional word embedding, the 50 dimensional space can be split into two parts: The bias-direction $g$, and the remaining 49 dimensions, which we'll call $g_{\perp}$. In linear algebra, we say that the 49 dimensional $g_{\perp}$ is perpendicular (or "othogonal") to $g$, meaning it is at 90 degrees to $g$. The neutralization step takes a vector such as $e_{receptionist}$ and zeros out the component in the direction of $g$, giving us $e_{receptionist}^{debiased}$.
Even though $g_{\perp}$ is 49 dimensional, given the limitations of what we can draw on a screen, we illustrate it using a 1 dimensional axis below.

 Figure 2: The word vector for "receptionist" represented before and after applying the neutralize operation.

Exercise: Implement neutralize() to remove the bias of words such as "receptionist" or "scientist". Given an input embedding $e$, you can use the following formulas to compute $e^{debiased}$:
$$e^{bias_component} = \frac{e \cdot g}{||g||_2^2} * g\tag{2}$$
$$e^{debiased} = e - e^{bias_component}\tag{3}$$
If you are an expert in linear algebra, you may recognize $e^{bias_component}$ as the projection of $e$ onto the direction $g$. If you're not an expert...
Can you write Python code for it?

def neutralize(word, g, word_to_vec_map):
    """
    Removes the bias of "word" by projecting it on the space orthogonal to the bias axis.
    This function ensures that gender neutral words are zero in the gender subspace.

    Arguments:
        word -- string indicating the word to debias
        g -- numpy-array of shape (50,), corresponding to the bias axis (such as gender)
        word_to_vec_map -- dictionary mapping words to their corresponding vectors.

    Returns:
        e_debiased -- neutralized word vector representation of the input "word"
    """

    ### START CODE HERE ###
    # Select word vector representation of "word". Use word_to_vec_map. (≈ 1 line)
    e = word_to_vec_map[word]

    # Compute e_biascomponent using the formula give above. (≈ 1 line)
    e_biascomponent = (np.dot(e, g)/(np.linalg.norm(g)**2)) * g

    # Neutralize e by substracting e_biascomponent from it
    # e_debiased should be equal to its orthogonal projection. (≈ 1 line)
    e_debiased = e - e_biascomponent
    ### END CODE HERE ###

    return e_debiased

e = "receptionist"
print("cosine similarity between " + e + " and g, before neutralizing: ", cosine_similarity(word_to_vec_map["receptionist"], g))

e_debiased = neutralize("receptionist", g, word_to_vec_map)
print("cosine similarity between " + e + " and g, after neutralizing: ", cosine_similarity(e_debiased, g))


I am working on the file "Course 5/Operations on word vectors v2.ipynb".
The first task is:
Expected Output:

            **cosine_similarity(father, mother)** =

         0.890903844289

            **cosine_similarity(ball, crocodile)** =

         0.274392462614

            **cosine_similarity(france - paris, rome - italy)** =

         -0.675147930817

After you get the correct expected output, please feel free to modify the inputs and measure the cosine similarity between other pairs of words! Playing around the cosine similarity of other inputs will give you a better sense of how word vectors behave.
2 - Word analogy task
In the word analogy task, we complete the sentence "a is to b as c is to ____". An example is  'man is to woman as king is to queen' . In detail, we are trying to find a word d, such that the associated word vectors $e_a, e_b, e_c, e_d$ are related in the following manner: $e_b - e_a \approx e_d - e_c$. We will measure the similarity between $e_b - e_a$ and $e_d - e_c$ using cosine similarity.
Exercise: Complete the code below to be able to perform word analogies!
Can you write Python code for it?

# GRADED FUNCTION: complete_analogy

def complete_analogy(word_a, word_b, word_c, word_to_vec_map):
    """
    Performs the word analogy task as explained above: a is to b as c is to ____.

    Arguments:
    word_a -- a word, string
    word_b -- a word, string
    word_c -- a word, string
    word_to_vec_map -- dictionary that maps words to their corresponding vectors.

    Returns:
    best_word --  the word such that v_b - v_a is close to v_best_word - v_c, as measured by cosine similarity
    """

    # convert words to lower case
    word_a, word_b, word_c = word_a.lower(), word_b.lower(), word_c.lower()

    ### START CODE HERE ###
    # Get the word embeddings v_a, v_b and v_c (≈1-3 lines)
    e_a, e_b, e_c = word_to_vec_map[word_a], word_to_vec_map[word_b], word_to_vec_map[word_c]
    ### END CODE HERE ###

    words = word_to_vec_map.keys()
    max_cosine_sim = -100              # Initialize max_cosine_sim to a large negative number
    best_word = None                   # Initialize best_word with None, it will help keep track of the word to output

    # loop over the whole word vector set
    for w in words:
        # to avoid best_word being one of the input words, pass on them.
        if w in [word_a, word_b, word_c] :
            continue

        ### START CODE HERE ###
        # Compute cosine similarity between the vector (e_b - e_a) and the vector ((w's vector representation) - e_c)  (≈1 line)
        cosine_sim = cosine_similarity(e_b - e_a, word_to_vec_map[w] - e_c)

        # If the cosine_sim is more than the max_cosine_sim seen so far,
            # then: set the new max_cosine_sim to the current cosine_sim and the best_word to the current word (≈3 lines)
        if cosine_sim > max_cosine_sim:
            max_cosine_sim = cosine_sim
            best_word = w
        ### END CODE HERE ###

    return best_word


I am working on the file "Course 5/Operations on word vectors v2.ipynb".
The first task is:
Expected Output:

            **italy -> italian** ::

         spain -> spanish

            **india -> delhi** ::

         japan -> tokyo

            **man -> woman ** ::

         boy -> girl

            **small -> smaller ** ::

         large -> larger

Once you get the correct expected output, please feel free to modify the input cells above to test your own analogies. Try to find some other analogy pairs that do work, but also find some where the algorithm doesn't give the right answer: For example, you can try small->smaller as big->?.
Congratulations!
You've come to the end of this assignment. Here are the main points you should remember:

Cosine similarity a good way to compare similarity between pairs of word vectors. (Though L2 distance works too.)
For NLP applications, using a pre-trained set of word vectors from the internet is often a good way to get started.

Even though you have finished the graded portions, we recommend you take a look too at the rest of this notebook.
Congratulations on finishing the graded portions of this notebook!
3 - Debiasing word vectors (OPTIONAL/UNGRADED)
In the following exercise, you will examine gender biases that can be reflected in a word embedding, and explore algorithms for reducing the bias. In addition to learning about the topic of debiasing, this exercise will also help hone your intuition about what word vectors are doing. This section involves a bit of linear algebra, though you can probably complete it even without being expert in linear algebra, and we encourage you to give it a shot. This portion of the notebook is optional and is not graded.
Lets first see how the GloVe word embeddings relate to gender. You will first compute a...
Can you write Python code for it?

g = word_to_vec_map['woman'] - word_to_vec_map['man']
print(g)


I am working on the file "Course 5/Operations on word vectors v2.ipynb".
The first task is:
Expected Output: The second result is essentially 0, up to numerical roundof (on the order of $10^{-17}$).

            **cosine similarity between receptionist and g, before neutralizing:** :

         0.330779417506

            **cosine similarity between receptionist and g, after neutralizing:** :

         -3.26732746085e-17

3.2 - Equalization algorithm for gender-specific words
Next, lets see how debiasing can also be applied to word pairs such as "actress" and "actor." Equalization is applied to pairs of words that you might want to have differ only through the gender property. As a concrete example, suppose that "actress" is closer to "babysit" than "actor." By applying neutralizing to "babysit" we can reduce the gender-stereotype associated with babysitting. But this still does not guarantee that "actor" and "actress" are equidistant from "babysit." The equalization algorithm takes care of this.
The key idea behind equalization is to make sure that a particular pair of words are equi-distant from the 49-dimensional $g_\perp$. The equalization step also ensures that the two equalized steps are now the same distance from $e_{receptionist}^{debiased}$, or from any other work that has been neutralized. In pictures, this is how equalization works:

The derivation of the linear algebra to do this is a bit more complex. (See Bolukbasi et al., 2016 for details.) But the key equations are:
$$ \mu = \frac{e_{w1} + e_{w2}}{2}\tag{4}$$
$$ \mu_{B} = \frac {\mu \cdot \text{bias_axis}}{||\text{bias_axis}||_2^2} *\text{bias_axis}
\tag{5}$$
$$\mu_{\perp} = \mu - \mu_{B} \tag{6}$$
$$ e_{w1B} = \frac {e_{w1} \cdot \text{bias_axis}}{||\text{bias_axis}||_2^2} \text{bias_axis}
\tag{7}$$
$$ e_{w2B} = \frac {e_{w2} \cdot \text{bias_axis}}{||\text{bias_axis}||_2^2}...
Can you write Python code for it?

def equalize(pair, bias_axis, word_to_vec_map):
    """
    Debias gender specific words by following the equalize method described in the figure above.

    Arguments:
    pair -- pair of strings of gender specific words to debias, e.g. ("actress", "actor")
    bias_axis -- numpy-array of shape (50,), vector corresponding to the bias axis, e.g. gender
    word_to_vec_map -- dictionary mapping words to their corresponding vectors

    Returns
    e_1 -- word vector corresponding to the first word
    e_2 -- word vector corresponding to the second word
    """

    ### START CODE HERE ###
    # Step 1: Select word vector representation of "word". Use word_to_vec_map. (≈ 2 lines)
    w1, w2 = pair
    e_w1, e_w2 = word_to_vec_map[w1], word_to_vec_map[w2]

    # Step 2: Compute the mean of e_w1 and e_w2 (≈ 1 line)
    mu = (e_w1 + e_w2)/2

    # Step 3: Compute the projections of mu over the bias axis and the orthogonal axis (≈ 2 lines)
    mu_B = (np.dot(mu, bias_axis)/(np.linalg.norm(bias_axis)**2)) * bias_axis
    mu_orth = mu - mu_B

    # Step 4: Use equations (7) and (8) to compute e_w1B and e_w2B (≈2 lines)
    e_w1B = (np.dot(e_w1, bias_axis)/(np.linalg.norm(bias_axis)**2)) * bias_axis
    e_w2B = (np.dot(e_w2, bias_axis)/(np.linalg.norm(bias_axis)**2)) * bias_axis

    # Step 5: Adjust the Bias part of e_w1B and e_w2B using the formulas (9) and (10) given above (≈2 lines)
    corrected_e_w1B = (np.abs(1 - np.linalg.norm(mu_orth)**2)**0.5) * ((e_w1B - mu_B)/ np.linalg.norm(e_w1 - mu_orth - mu_B))
    corrected_e_w2B = (np.abs(1 - np.linalg.norm(mu_orth)**2)**0.5) * ((e_w2B - mu_B)/ np.linalg.norm(e_w2 - mu_orth - mu_B))

    # Step 6: Debias by equalizing e1 and e2 to the sum of their corrected projections (≈2 lines)
    e1 = corrected_e_w1B + mu_orth
    e2 = corrected_e_w2B + mu_orth

    ### END CODE HERE ###

    return e1, e2

print("cosine similarities before...


I am working on the file "Course 5/Operations on word vectors v2.ipynb".
The first task is:
Next, lets load the word vectors. For this assignment, we will use 50-dimensional GloVe vectors to represent words. Run the following cell to load the word_to_vec_map.
Can you write Python code for it?

words, word_to_vec_map = read_glove_vecs('data/glove.6B.50d.txt')


I am working on the file "Course 5/Operations on word vectors v2.ipynb".
The first task is:
Run the cell below to test your code, this may take 1-2 minutes.
Can you write Python code for it?

triads_to_try = [('italy', 'italian', 'spain'), ('india', 'delhi', 'japan'), ('man', 'woman', 'boy'), ('small', 'smaller', 'large')]
for triad in triads_to_try:
    print ('{} -> {} :: {} -> {}'.format( *triad, complete_analogy(*triad,word_to_vec_map)))


I am working on the file "Course 5/Operations on word vectors v2.ipynb".
The first task is:
You've loaded:
- words: set of words in the vocabulary.
- word_to_vec_map: dictionary mapping words to their GloVe vector representation.
You've seen that one-hot vectors do not do a good job cpaturing what words are similar. GloVe vectors provide much more useful information about the meaning of individual words. Lets now see how you can use GloVe vectors to decide how similar two words are.
1 - Cosine similarity
To measure how similar two words are, we need a way to measure the degree of similarity between two embedding vectors for the two words. Given two vectors $u$ and $v$, cosine similarity is defined as follows:
$$\text{CosineSimilarity(u, v)} = \frac {u . v} {||u||_2 ||v||_2} = cos(\theta) \tag{1}$$
where $u.v$ is the dot product (or inner product) of two vectors, $||u||_2$ is the norm (or length) of the vector $u$, and $\theta$ is the angle between $u$ and $v$. This similarity depends on the angle between $u$ and $v$. If $u$ and $v$ are very similar, their cosine similarity will be close to 1; if they are dissimilar, the cosine similarity will take a smaller value.

 Figure 1: The cosine of the angle between two vectors is a measure of how similar they are

Exercise: Implement the function cosine_similarity() to evaluate similarity between word vectors.
Reminder: The norm of $u$ is defined as $ ||u||2 = \sqrt{\sum{i=1}^{n} u_i^2}$
Can you write Python code for it?

# GRADED FUNCTION: cosine_similarity

def cosine_similarity(u, v):
    """
    Cosine similarity reflects the degree of similariy between u and v

    Arguments:
        u -- a word vector of shape (n,)
        v -- a word vector of shape (n,)

    Returns:
        cosine_similarity -- the cosine similarity between u and v defined by the formula above.
    """

    distance = 0.0

    ### START CODE HERE ###
    # Compute the dot product between u and v (≈1 line)
    dot = np.dot(u, v)
    # Compute the L2 norm of u (≈1 line)
    norm_u = np.linalg.norm(u)

    # Compute the L2 norm of v (≈1 line)
    norm_v = np.linalg.norm(v)
    # Compute the cosine similarity defined by formula (1) (≈1 line)
    cosine_similarity = dot / (norm_u * norm_v)
    ### END CODE HERE ###

    return cosine_similarity

father = word_to_vec_map["father"]
mother = word_to_vec_map["mother"]
ball = word_to_vec_map["ball"]
crocodile = word_to_vec_map["crocodile"]
france = word_to_vec_map["france"]
italy = word_to_vec_map["italy"]
paris = word_to_vec_map["paris"]
rome = word_to_vec_map["rome"]

print("cosine_similarity(father, mother) = ", cosine_similarity(father, mother))
print("cosine_similarity(ball, crocodile) = ",cosine_similarity(ball, crocodile))
print("cosine_similarity(france - paris, rome - italy) = ",cosine_similarity(france - paris, rome - italy))


I am working on the file "Course Project - Michael Chambers.ipynb".
The first task is:
(1) Demo Script: msd_script.py
(2) Demo Module: msd_module.py
Can you write Python code for it?

#Import msd_module
%matplotlib inline
import msd_module

#Check Docstring
msd_module?

project1 = msd_module.msd_96()

project1.create_df('data.txt')

project1.df

project1.split_plates()

project1.dilution

project1.create_dilution(5,3,8)

project1.dilution

project1.split_plates()


I am working on the file "Course_1_Part_4_Lesson_2_Notebook.ipynb".
The first task is:
Calling load_data on this object will give you two sets of two lists, these will be the training and testing values for the graphics that contain the clothing items and their labels.
Can you write Python code for it?

(training_images, training_labels), (test_images, test_labels) = mnist.load_data()


I am working on the file "Course_1_Part_4_Lesson_2_Notebook.ipynb".
The first task is:
Exercise 4:
Consider the final (output) layers. Why are there 10 of them? What would happen if you had a different amount than 10? For example, try training the network with 5
You get an error as soon as it finds an unexpected value. Another rule of thumb -- the number of neurons in the last layer should match the number of classes you are classifying for. In this case it's the digits 0-9, so there are 10 of them, hence you should have 10 neurons in your final layer.
Can you write Python code for it?

import tensorflow as tf
print(tf.__version__)

mnist = tf.keras.datasets.mnist

(training_images, training_labels) ,  (test_images, test_labels) = mnist.load_data()

training_images = training_images/255.0
test_images = test_images/255.0

model = tf.keras.models.Sequential([tf.keras.layers.Flatten(),
                                    tf.keras.layers.Dense(64, activation=tf.nn.relu),
                                    tf.keras.layers.Dense(5, activation=tf.nn.softmax)])

model.compile(optimizer = 'adam',
              loss = 'sparse_categorical_crossentropy')

model.fit(training_images, training_labels, epochs=5)

model.evaluate(test_images, test_labels)

classifications = model.predict(test_images)

print(classifications[0])
print(test_labels[0])


I am working on the file "Course_1_Part_4_Lesson_2_Notebook.ipynb".
The first task is:
Exercise 5:
Consider the effects of additional layers in the network. What will happen if you add another layer between the one with 512 and the final layer with 10.
Ans: There isn't a significant impact -- because this is relatively simple data. For far more complex data (including color images to be classified as flowers that you'll see in the next lesson), extra layers are often necessary.
Can you write Python code for it?

import tensorflow as tf
print(tf.__version__)

mnist = tf.keras.datasets.mnist

(training_images, training_labels) ,  (test_images, test_labels) = mnist.load_data()

training_images = training_images/255.0
test_images = test_images/255.0

model = tf.keras.models.Sequential([tf.keras.layers.Flatten(),
                                    tf.keras.layers.Dense(512, activation=tf.nn.relu),
                                    tf.keras.layers.Dense(256, activation=tf.nn.relu),
                                    tf.keras.layers.Dense(5, activation=tf.nn.softmax)])

model.compile(optimizer = 'adam',
              loss = 'sparse_categorical_crossentropy')

model.fit(training_images, training_labels, epochs=5)

model.evaluate(test_images, test_labels)

classifications = model.predict(test_images)

print(classifications[0])
print(test_labels[0])


I am working on the file "Course_1_Part_4_Lesson_2_Notebook.ipynb".
The first task is:
Exercise 7:
Before you trained, you normalized the data, going from values that were 0-255 to values that were 0-1. What would be the impact of removing that? Here's the complete code to give it a try. Why do you think you get different results?
Can you write Python code for it?

import tensorflow as tf
print(tf.__version__)
mnist = tf.keras.datasets.mnist
(training_images, training_labels), (test_images, test_labels) = mnist.load_data()
training_images=training_images/255.0
test_images=test_images/255.0
model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(),
  tf.keras.layers.Dense(512, activation=tf.nn.relu),
  tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
model.fit(training_images, training_labels, epochs=5)
model.evaluate(test_images, test_labels)
classifications = model.predict(test_images)
print(classifications[0])
print(test_labels[0])


I am working on the file "Course_1_Part_4_Lesson_2_Notebook.ipynb".
The first task is:
Exercise 8:
Earlier when you trained for extra epochs you had an issue where your loss might change. It might have taken a bit of time for you to wait for the training to do that, and you might have thought 'wouldn't it be nice if I could stop the training when I reach a desired value?' -- i.e. 95% accuracy might be enough for you, and if you reach that after 3 epochs, why sit around waiting for it to finish a lot more epochs....So how would you fix that? Like any other program...you have callbacks! Let's see them in action...
Can you write Python code for it?

import tensorflow as tf
print(tf.__version__)

class myCallback(tf.keras.callbacks.Callback):
  def on_epoch_end(self, epoch, logs={}):
    if(logs.get('loss')<0.4):
      print("\nReached 60% accuracy so cancelling training!")
      self.model.stop_training = True

callbacks = myCallback()
mnist = tf.keras.datasets.fashion_mnist
(training_images, training_labels), (test_images, test_labels) = mnist.load_data()
training_images=training_images/255.0
test_images=test_images/255.0
model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(),
  tf.keras.layers.Dense(512, activation=tf.nn.relu),
  tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
model.fit(training_images, training_labels, epochs=5, callbacks=[callbacks])


I am working on the file "Course_1_Part_4_Lesson_2_Notebook.ipynb".
The first task is:
Hint: try running print(test_labels[0]) -- and you'll get a 9. Does that help you understand why this list looks the way it does?
Can you write Python code for it?


I am working on the file "Course_1_Part_4_Lesson_2_Notebook.ipynb".
The first task is:
Now you might be wondering why there are 2 sets...training and testing -- remember we spoke about this in the intro? The idea is to have 1 set of data for training, and then another set of data...that the model hasn't yet seen...to see how good it would be at classifying values. After all, when you're done, you're going to want to try it out with data that it hadn't previously seen!
Let's now design the model. There's quite a few new concepts here, but don't worry, you'll get the hang of them.
Can you write Python code for it?

model = tf.keras.models.Sequential([tf.keras.layers.Flatten(),
                                    tf.keras.layers.Dense(128, activation=tf.nn.relu),
                                    tf.keras.layers.Dense(10, activation=tf.nn.softmax)])


I am working on the file "Course_1_Part_4_Lesson_2_Notebook.ipynb".
The first task is:
Question 1. Increase to 1024 Neurons -- What's the impact?

Training takes longer, but is more accurate
Training takes longer, but no impact on accuracy
Training takes the same time, but is more accurate

Answer
The correct answer is (1) by adding more Neurons we have to do more calculations, slowing down the process, but in this case they have a good impact -- we do get more accurate. That doesn't mean it's always a case of 'more is better', you can hit the law of diminishing returns very quickly!
Exercise 3:
What would happen if you remove the Flatten() layer. Why do you think that's the case?
You get an error about the shape of the data. It may seem vague right now, but it reinforces the rule of thumb that the first layer in your network should be the same shape as your data. Right now our data is 28x28 images, and 28 layers of 28 neurons would be infeasible, so it makes more sense to 'flatten' that 28,28 into a 784x1. Instead of wriitng all the code to handle that ourselves, we add the Flatten() layer at the begining, and when the arrays are loaded into the model later, they'll automatically be flattened for us.
Can you write Python code for it?

import tensorflow as tf
print(tf.__version__)

mnist = tf.keras.datasets.mnist

(training_images, training_labels) ,  (test_images, test_labels) = mnist.load_data()

training_images = training_images/255.0
test_images = test_images/255.0

model = tf.keras.models.Sequential([#tf.keras.layers.Flatten(),
                                    tf.keras.layers.Dense(64, activation=tf.nn.relu),
                                    tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

model.compile(optimizer = 'adam',
              loss = 'sparse_categorical_crossentropy')

model.fit(training_images, training_labels, epochs=5)

model.evaluate(test_images, test_labels)

classifications = model.predict(test_images)

print(classifications[0])
print(test_labels[0])


I am working on the file "Course_1_Part_4_Lesson_2_Notebook.ipynb".
The first task is:
The Fashion MNIST data is available directly in the tf.keras datasets API. You load it like this:
Can you write Python code for it?


I am working on the file "Course_1_Part_4_Lesson_2_Notebook.ipynb".
The first task is:
What does this list represent?

It's 10 random meaningless values
It's the first 10 classifications that the computer made
It's the probability that this item is each of the 10 classes

Answer:
The correct answer is (3)
The output of the model is a list of 10 numbers. These numbers are a probability that the value being classified is the corresponding value, i.e. the first value in the list is the probability that the handwriting is of a '0', the next is a '1' etc. Notice that they are all VERY LOW probabilities.
For the 7, the probability was .999+, i.e. the neural network is telling us that it's almost certainly a 7.
How do you know that this list tells you that the item is an ankle boot?

There's not enough information to answer that question
The 10th element on the list is the biggest, and the ankle boot is labelled 9
The ankle boot is label 9, and there are 0->9 elements in the list

Answer
The correct answer is (2). Both the list and the labels are 0 based, so the ankle boot having label 9 means that it is the 10th of the 10 classes. The list having the 10th element being the highest value means that the Neural Network has predicted that the item it is classifying is most likely an ankle boot
Exercise 2:
Let's now look at the layers in your model. Experiment with different values for the dense layer with 512 neurons. What different results do you get for loss, training time etc? Why do you think that's the case?
Can you write Python code for it?

import tensorflow as tf
print(tf.__version__)

mnist = tf.keras.datasets.mnist

(training_images, training_labels) ,  (test_images, test_labels) = mnist.load_data()

training_images = training_images/255.0
test_images = test_images/255.0

model = tf.keras.models.Sequential([tf.keras.layers.Flatten(),
                                    tf.keras.layers.Dense(1024, activation=tf.nn.relu),
                                    tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

model.compile(optimizer = 'adam',
              loss = 'sparse_categorical_crossentropy')

model.fit(training_images, training_labels, epochs=5)

model.evaluate(test_images, test_labels)

classifications = model.predict(test_images)

print(classifications[0])
print(test_labels[0])


I am working on the file "Course_1_Part_6_Lesson_2_Notebook.ipynb".
The first task is:
EXERCISES

Try editing the convolutions. Change the 32s to either 16 or 64. What impact will this have on accuracy and/or training time.

Remove the final Convolution. What impact will this have on accuracy or training time?

How about adding more Convolutions? What impact do you think this will have? Experiment with it.

Remove all Convolutions but the first. What impact do you think this will have? Experiment with it.

In the previous lesson you implemented a callback to check on the loss function and to cancel training once it hit a certain amount. See if you can implement that here!
Can you write Python code for it?

import tensorflow as tf
print(tf.__version__)
mnist = tf.keras.datasets.mnist
(training_images, training_labels), (test_images, test_labels) = mnist.load_data()
training_images=training_images.reshape(60000, 28, 28, 1)
training_images=training_images / 255.0
test_images = test_images.reshape(10000, 28, 28, 1)
test_images=test_images/255.0
model = tf.keras.models.Sequential([
  tf.keras.layers.Conv2D(32, (3,3), activation='relu', input_shape=(28, 28, 1)),
  tf.keras.layers.MaxPooling2D(2, 2),
  tf.keras.layers.Flatten(),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(training_images, training_labels, epochs=10)
test_loss, test_acc = model.evaluate(test_images, test_labels)
print(test_acc)


I am working on the file "Course_1_Part_6_Lesson_2_Notebook.ipynb".
The first task is:
It's likely gone up to about 93% on the training data and 91% on the validation data.
That's significant, and a step in the right direction!
Try running it for more epochs -- say about 20, and explore the results! But while the results might seem really good, the validation results may actually go down, due to something called 'overfitting' which will be discussed later.
(In a nutshell, 'overfitting' occurs when the network learns the data from the training set really well, but it's too specialised to only that data, and as a result is less effective at seeing other data. For example, if all your life you only saw red shoes, then when you see a red shoe you would be very good at identifying it, but blue suade shoes might confuse you...and you know you should never mess with my blue suede shoes.)
Then, look at the code again, and see, step by step how the Convolutions were built:
Step 1 is to gather the data. You'll notice that there's a bit of a change here in that the training data needed to be reshaped. That's because the first convolution expects a single tensor containing everything, so instead of 60,000 28x28x1 items in a list, we have a single 4D list that is 60,000x28x28x1, and the same for the test images. If you don't do this, you'll get an error when training as the Convolutions do not recognize the shape.
import tensorflow as tf
mnist = tf.keras.datasets.fashion_mnist
(training_images, training_labels), (test_images, test_labels) = mnist.load_data()
training_images=training_images.reshape(60000, 28, 28, 1)
training_images=training_images / 255.0
test_images = test_images.reshape(10000, 28, 28, 1)
test_images=test_images/255.0
Next is to define your model. Now instead of the input layer at the top, you're going to add a Convolution. The parameters are:

The number of convolutions you want to generate. Purely arbitrary, but good to start with something in the order of 32
The size of the Convolution, in this case a 3x3 grid
The activation function to use -- in this case we'll use relu, which you...
Can you write Python code for it?

print(test_labels[:100])

import matplotlib.pyplot as plt
f, axarr = plt.subplots(3,4)
FIRST_IMAGE=0
SECOND_IMAGE=7
THIRD_IMAGE=26
CONVOLUTION_NUMBER = 1
from tensorflow.keras import models
layer_outputs = [layer.output for layer in model.layers]
activation_model = tf.keras.models.Model(inputs = model.input, outputs = layer_outputs)
for x in range(0,4):
  f1 = activation_model.predict(test_images[FIRST_IMAGE].reshape(1, 28, 28, 1))[x]
  axarr[0,x].imshow(f1[0, : , :, CONVOLUTION_NUMBER], cmap='inferno')
  axarr[0,x].grid(False)
  f2 = activation_model.predict(test_images[SECOND_IMAGE].reshape(1, 28, 28, 1))[x]
  axarr[1,x].imshow(f2[0, : , :, CONVOLUTION_NUMBER], cmap='inferno')
  axarr[1,x].grid(False)
  f3 = activation_model.predict(test_images[THIRD_IMAGE].reshape(1, 28, 28, 1))[x]
  axarr[2,x].imshow(f3[0, : , :, CONVOLUTION_NUMBER], cmap='inferno')
  axarr[2,x].grid(False)


I am working on the file "Course_2_Part_2_Lesson_3_Notebook.ipynb".
The first task is:
As you can see we go from the raw pixels of the images to increasingly abstract and compact representations. The representations downstream start highlighting what the network pays attention to, and they show fewer and fewer features being "activated"; most are set to zero. This is called "sparsity." Representation sparsity is a key feature of deep learning.
These representations carry increasingly less information about the original pixels of the image, but increasingly refined information about the class of the image. You can think of a convnet (or a deep network in general) as an information distillation pipeline.
Clean Up
Before running the next exercise, run the following cell to terminate the kernel and free memory resources:
Can you write Python code for it?

import os, signal
os.kill(os.getpid(), signal.SIGKILL)


I am working on the file "Course_2_Part_2_Lesson_3_Notebook.ipynb".
The first task is:
Let's find out the total number of horse and human images in the directories:
Can you write Python code for it?

print('total training horse images:', len(os.listdir(train_horse_dir)))
print('total training human images:', len(os.listdir(train_human_dir)))
print('total validation horse images:', len(os.listdir(validation_horse_dir)))
print('total validation human images:', len(os.listdir(validation_human_dir)))


I am working on the file "Course_2_Part_2_Lesson_3_Notebook.ipynb".
The first task is:
Now let's take a look at a few pictures to get a better sense of what they look like. First, configure the matplot parameters:
Can you write Python code for it?

%matplotlib inline

import matplotlib.pyplot as plt
import matplotlib.image as mpimg

# Parameters for our graph; we'll output images in a 4x4 configuration
nrows = 4
ncols = 4

# Index for iterating over images
pic_index = 0


I am working on the file "Course_2_Part_2_Lesson_3_Notebook.ipynb".
The first task is:
Now, display a batch of 8 horse and 8 human pictures. You can rerun the cell to see a fresh batch each time:
Can you write Python code for it?

# Set up matplotlib fig, and size it to fit 4x4 pics
fig = plt.gcf()
fig.set_size_inches(ncols * 4, nrows * 4)

pic_index += 8
next_horse_pix = [os.path.join(train_horse_dir, fname)
                for fname in train_horse_names[pic_index-8:pic_index]]
next_human_pix = [os.path.join(train_human_dir, fname)
                for fname in train_human_names[pic_index-8:pic_index]]

for i, img_path in enumerate(next_horse_pix+next_human_pix):
  # Set up subplot; subplot indices start at 1
  sp = plt.subplot(nrows, ncols, i + 1)
  sp.axis('Off') # Don't show axes (or gridlines)

  img = mpimg.imread(img_path)
  plt.imshow(img)

plt.show()


I am working on the file "Course_2_Part_2_Lesson_3_Notebook.ipynb".
The first task is:
Now, let's see what the filenames look like in the horses and humans training directories:
Can you write Python code for it?

train_horse_names = os.listdir(train_horse_dir)
print(train_horse_names[:10])

train_human_names = os.listdir(train_human_dir)
print(train_human_names[:10])

validation_horse_hames = os.listdir(validation_horse_dir)
print(validation_horse_hames[:10])

validation_human_names = os.listdir(validation_human_dir)
print(validation_human_names[:10])


I am working on the file "Course_2_Part_2_Lesson_3_Notebook.ipynb".
The first task is:
Running the Model
Let's now take a look at actually running a prediction using the model. This code will allow you to choose 1 or more files from your file system, it will then upload them, and run them through the model, giving an indication of whether the object is a horse or a human.
Can you write Python code for it?

import numpy as np
from google.colab import files
from keras.preprocessing import image

uploaded = files.upload()

for fn in uploaded.keys():

  # predicting images
  path = '/content/' + fn
  img = image.load_img(path, target_size=(300, 300))
  x = image.img_to_array(img)
  x = np.expand_dims(x, axis=0)

  images = np.vstack([x])
  classes = model.predict(images, batch_size=10)
  print(classes[0])
  if classes[0]>0.5:
    print(fn + " is a human")
  else:
    print(fn + " is a horse")


I am working on the file "Course_2_Part_2_Lesson_3_Notebook.ipynb".
The first task is:
The "output shape" column shows how the size of your feature map evolves in each successive layer. The convolution layers reduce the size of the feature maps by a bit due to padding, and each pooling layer halves the dimensions.
Next, we'll configure the specifications for model training. We will train our model with the binary_crossentropy loss, because it's a binary classification problem and our final activation is a sigmoid. (For a refresher on loss metrics, see the Machine Learning Crash Course.) We will use the rmsprop optimizer with a learning rate of 0.001. During training, we will want to monitor classification accuracy.
NOTE: In this case, using the RMSprop optimization algorithm is preferable to stochastic gradient descent (SGD), because RMSprop automates learning-rate tuning for us. (Other optimizers, such as Adam and Adagrad, also automatically adapt the learning rate during training, and would work equally well here.)
Can you write Python code for it?

from tensorflow.keras.optimizers import RMSprop

model.compile(loss='binary_crossentropy',
              optimizer=RMSprop(lr=0.001),
              metrics=['acc'])


I am working on the file "Course_2_Part_2_Lesson_3_Notebook.ipynb".
The first task is:
The contents of the .zip are extracted to the base directory /tmp/horse-or-human, which in turn each contain horses and humans subdirectories.
In short: The training set is the data that is used to tell the neural network model that 'this is what a horse looks like', 'this is what a human looks like' etc.
One thing to pay attention to in this sample: We do not explicitly label the images as horses or humans. If you remember with the handwriting example earlier, we had labelled 'this is a 1', 'this is a 7' etc.  Later you'll see something called an ImageGenerator being used -- and this is coded to read images from subdirectories, and automatically label them from the name of that subdirectory. So, for example, you will have a 'training' directory containing a 'horses' directory and a 'humans' one. ImageGenerator will label the images appropriately for you, reducing a coding step.
Let's define each of these directories:
Can you write Python code for it?

# Directory with our training horse pictures
train_horse_dir = os.path.join('/tmp/horse-or-human/horses')

# Directory with our training human pictures
train_human_dir = os.path.join('/tmp/horse-or-human/humans')

# Directory with our training horse pictures
validation_horse_dir = os.path.join('/tmp/validation-horse-or-human/horses')

# Directory with our training human pictures
validation_human_dir = os.path.join('/tmp/validation-horse-or-human/humans')


I am working on the file "Course_2_Part_2_Lesson_3_Notebook.ipynb".
The first task is:
The model.summary() method call prints a summary of the NN
Can you write Python code for it?


I am working on the file "Course_2_Part_2_Lesson_3_Notebook.ipynb".
The first task is:
We then add convolutional layers as in the previous example, and flatten the final result to feed into the densely connected layers.
Finally we add the densely connected layers.
Note that because we are facing a two-class classification problem, i.e. a binary classification problem, we will end our network with a sigmoid activation, so that the output of our network will be a single scalar between 0 and 1, encoding the probability that the current image is class 1 (as opposed to class 0).
Can you write Python code for it?

model = tf.keras.models.Sequential([
    # Note the input shape is the desired size of the image 300x300 with 3 bytes color
    # This is the first convolution
    tf.keras.layers.Conv2D(16, (3,3), activation='relu', input_shape=(300, 300, 3)),
    tf.keras.layers.MaxPooling2D(2, 2),
    # The second convolution
    tf.keras.layers.Conv2D(32, (3,3), activation='relu'),
    tf.keras.layers.MaxPooling2D(2,2),
    # The third convolution
    tf.keras.layers.Conv2D(64, (3,3), activation='relu'),
    tf.keras.layers.MaxPooling2D(2,2),
    # The fourth convolution
    tf.keras.layers.Conv2D(64, (3,3), activation='relu'),
    tf.keras.layers.MaxPooling2D(2,2),
    # The fifth convolution
    tf.keras.layers.Conv2D(64, (3,3), activation='relu'),
    tf.keras.layers.MaxPooling2D(2,2),
    # Flatten the results to feed into a DNN
    tf.keras.layers.Flatten(),
    # 512 neuron hidden layer
    tf.keras.layers.Dense(512, activation='relu'),
    # Only 1 output neuron. It will contain a value from 0-1 where 0 for 1 class ('horses') and 1 for the other ('humans')
    tf.keras.layers.Dense(1, activation='sigmoid')
])


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Base da recursão é a condição que faz o problema ser definitivamente resolvido. Caso essa condição, essa base da recursão, não seja satisfeita, o problema continua sendo reduzido em instâncias menores até que a condição passe a ser satisfeita.
Chamada recursiva é a linha onde a função faz uma chamada a ela mesma.
Função recursiva é a função que chama ela mesma.

A linha 2 tem a condição que é a base da recursão
A linha 5 tem a chamada recursiva
Para o algoritmo funcionar corretamente, é necessário trocar a linha 3 por “return 1”

if (n < 2):
if (n <= 1):

No <espaço A> e no <espaço C>

looping infinito

Resultado: 6. Chamadas recursivas: nenhuma.

Resultado: 20. Chamadas recursivas: 24

1
Can you write Python code for it?

def x(n):
    if n == 0:
        #<espaço A>
        print(n)
    else:
        #<espaço B>
        x(n-1)
        print(n)
        #<espaço C>
    #<espaço D>
#<espaço E>

x(10)

def x(n):
    if n >= 0 or n <= 2:
        print(n)
        # return n
    else:
        print(n-1)
        print(n-2)
        print(n-3)
        #return x(n-1) + x(n-2) + x(n-3)

print(x(6))

def busca_binaria(lista, elemento, min=0, max=None):
    if max == None:
        max = len(lista)-1

    if max < min:
        return False
    else:
        meio = min + (max-min)//2
        print(lista[meio])

    if lista[meio] > elemento:
        return busca_binaria(lista, elemento, min, meio - 1)
    elif lista[meio] < elemento:
        return busca_binaria(lista, elemento, meio + 1, max)
    else:
        return meio

a = [-10, -2, 0, 5, 66, 77, 99, 102, 239, 567, 875, 934]

a

busca_binaria(a, 99)


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Busca Binária
Objetivo: localizar o elemento x em uma lista

Considere o elemento m do meio da lista
se x == m ==> encontrou!
se x < m ==> procure apenas na 1ª metade (da esquerda)
se x > m ==> procure apenas na 2ª metade (da direita),
repetir o processo até que o x seja encontrado ou que a sub-lista em questão esteja vazia
Can you write Python code for it?

class Buscador:

    def busca_por_titulo(self, playlist, titulo):
        for i in range(len(playlist)):
            if playlist[i].titulo == titulo:
                return i
        return -1

    def busca_binaria(self, lista, x):
        primeiro = 0
        ultimo = len(lista) - 1

        while primeiro <= ultimo:
            meio = (primeiro + ultimo) // 2
            if lista[meio] == x:
                return meio
            else:
                if x < lista[meio]: # busca na primeira metade da lista
                    ultimo = meio - 1 # já foi visto que não está no elemento meio, então vai um a menos
                else:
                    primeiro = meio + 1
        return -1

lista = [-100, 0, 20, 30, 50, 100, 3000, 5000]
b = Buscador()
b.busca_binaria(lista, 30)


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Comparação de Desempenho
Módulo time:

função time()
devolve o tempo decorrido (em segundos) desde 1/1/1970 (no Unix)

Para medir um intervalo de tempo
import time
antes = time.time()
algoritmo_a_ser_cronometrado()
depois = time.time()
print("A execução do algoritmo demorou ", depois - antes, "segundos")
Can you write Python code for it?

class Ordenador:

    def selecao_direta(self, lista):

        fim = len(lista)

        for i in range(fim - 1):
            # Inicialmente o menor elemento já visto é o i-ésimo
            posicao_do_minimo = i

            for j in range(i + 1, fim):
                if lista[j] < lista[posicao_do_minimo]: # encontrou um elemento menor...
                    posicao_do_minimo = j               # ...substitui.

            # Coloca o menor elemento encontrado no início da sub-lista
            # Para isso, troca de lugar os elementos nas posições i e posicao_do_minimo

            lista[i], lista[posicao_do_minimo] = lista[posicao_do_minimo], lista[i]

    def bolha(self, lista):

        fim = len(lista)

        for i in range(fim - 1, 0, -1):
            for j in range(i):
                if lista[j] > lista[j + 1]:
                    lista[j], lista[j + 1] = lista[j + 1], lista[j]

import random
import time

class ContaTempos:

    def lista_aleatoria(self, n): # n = número de elementos da lista
        from random import randrange
        lista = [0 for x in range(n)] # lista com n elementos, todos sendo zero
        for i in range(n):
            lista[i] = random.randrange(1000) # inteiros entre 0 e 999
        return lista

    def compara(self, n):

        lista1 = self.lista_aleatoria(n)
        lista2 = lista1

        o = Ordenador()

        antes = time.time()
        o.bolha(lista1)
        depois = time.time()
        print("Bolha demorou", depois - antes, "segundos")

        antes = time.time()
        o.selecao_direta(lista2)
        depois = time.time()
        print("Seleção direta demorou", depois - antes, "segundos")

c = ContaTempos()
c.compara(1000)

print("Diferença de", 0.16308164596557617 - 0.05245494842529297)

c.compara(5000)


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Complexidade Computacional

Análise matemática do desempenho de um algoritmo

Estudo analítico de:

Quantas operações um algoritmo requer para que ele seja executado
Quanto tempo ele vai demorar para ser executado
Quanto de memória ele vai ocupar

Análise da Busca Sequencial
Exemplo:
Lista telefônica de São Paulo, supondo 2 milhões de telefones fixos.
Supondo que cada iteração do for comparação de string dure 1 milissegundo.
Pior caso: 2000s = 33,3 minutos
Caso médio (1 milhão): 1000s = 16,6 minutos
Complexidade Computacional da Busca Sequencial

Dada uma lista de tamanho n

A complexidade computacional da busca sequencial é:

n, no pior caso
n/2, no caso médio

Conclusão

Busca sequencial é boa pois é bem simples

Funciona bem quando a busca é feita num volume pequeno de dados

Sua Complexidade Computacional é muito alta

É muito lenta quando o volume de dados é grande
Portanto, dizemos que é um algoritmo ineficiente

Algoritmo de Ordenação Seleção Direta
Seleção Direta
A cada passo, busca pelo menor elemento do pedaço ainda não ordenado da lista e o coloca no início da lista
No 1º passo, busca o menor elemento de todos e coloca na posição inicial da lista.
No 2º passo, busca o 2º menor elemento da lista e coloca na 2ª posição da lista.
No 3º passo, busca o 3º menor elemento da lista e coloca na 3ª posição da lista.
Repete até terminar a lista
Can you write Python code for it?

class Ordenador:

    def selecao_direta(self, lista):

        fim = len(lista)

        for i in range(fim - 1):
            # Inicialmente o menor elemento já visto é o i-ésimo
            posicao_do_minimo = i

            for j in range(i + 1, fim):
                if lista[j] < lista[posicao_do_minimo]: # encontrou um elemento menor...
                    posicao_do_minimo = j               # ...substitui.

            # Coloca o menor elemento encontrado no início da sub-lista
            # Para isso, troca de lugar os elementos nas posições i e posicao_do_minimo

            lista[i], lista[posicao_do_minimo] = lista[posicao_do_minimo], lista[i]

lista = [10, 3, 8, -10, 200, 17, 32]
o = Ordenador()

o.selecao_direta(lista)

lista

lista_nomes = ['maria', 'carlos', 'wilson', 'ana']
o.selecao_direta(lista_nomes)
lista_nomes

import random

print(random.randint(1, 10))

from random import shuffle
x = [i for i in range(100)]
shuffle(x)
x

o.selecao_direta(x)
x

def comprova_ordem(list):

    flag = True

    for i in range(len(list) - 1):
        if list[i] > list[i + 1]:
            flag = False

    return flag

comprova_ordem(x)

list = [1, 2, 3, 4, 5]
list2 = [1, 3, 2, 4, 5]

comprova_ordem(list)

comprova_ordem(list2)

def busca_sequencial(seq, x):
    for i in range(len(seq)):
        if seq[i] == x:
            return True
    return False

def selecao_direta(lista):
    fim = len(lista)
    for i in range(fim-1):
        pos_menor = i
        for j in range(i+1,fim):
            if lista[j] < lista[pos_menor]:
                pos_menor = j
        lista[i],lista[pos_menor] = lista[pos_menor],lista[i]
    return lista

numeros = [55,33,0,900,-432,10,77,2,11]


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Complexidade da Busca Binária
Dado uma lista de n elementos
No pior caso, teremos que efetuar:
$$log_2n$$ comparações
No exemplo da lista telefônica (com 2 milhões de números):
$$log_2(2 milhões) = 20,9$$
Portanto: resposta em menos de 21 milissegundos!
Conclusão

Busca Binária é um algoritmo bastante eficiente

Ao estudar a eficiência de um algoritmo é interessante:

Analisar a complexidade computacional
Realizar experimentos medindo o desempenho

Tarefa de programação: Lista de exercícios - 5
Exercício 1: Busca binária
Implemente a função busca(lista, elemento), que busca um determinado elemento em uma lista e devolve o índice correspondente à posição do elemento encontrado. Utilize o algoritmo de busca binária. Nos casos em que o elemento buscado não existir na lista, a função deve devolver o booleano False.
Além de devolver o índice correspondente à posição do elemento encontrado, sua função deve imprimir cada um dos índices testados pelo algoritmo.
Exemplo:
busca(['a', 'e', 'i'], 'e')
1
deve devolver => 1
busca([1, 2, 3, 4, 5], 6)
2
3
4
deve devolver => False
busca([1, 2, 3, 4, 5, 6], 4)
2
4
3
deve devolver => 3
Can you write Python code for it?

def busca(lista, elemento):

    primeiro = 0
    ultimo = len(lista) - 1

    while primeiro <= ultimo:
        meio = (primeiro + ultimo) // 2
        if lista[meio] == elemento:
            print(meio)
            return meio
        else:
            if elemento < lista[meio]: # busca na primeira metade da lista
                ultimo = meio - 1 # já foi visto que não está no elemento meio, então vai um a menos
                print(meio) # função deve imprimir cada um dos índices testados pelo algoritmo.
            else:
                primeiro = meio + 1
                print(meio)
    return False

busca(['a', 'e', 'i'], 'e')

busca([1, 2, 3, 4, 5], 6)

busca([1, 2, 3, 4, 5, 6], 4)


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Códigos Testáveis
Can you write Python code for it?

import math

class Bhaskara:

    def delta(self, a, b, c):
        return b ** 2 - 4 * a * c

    def main(self):
        a_digitado = float(input("Digite o valor de a:"))
        b_digitado = float(input("Digite o valor de b:"))
        c_digitado = float(input("Digite o valor de c:"))
        print(self.calcula_raizes(a_digitado, b_digitado, c_digitado))

    def calcula_raizes(self, a, b, c):
        d = self.delta(self, a, b, c)
        if d == 0:
            raiz1 = (-b + math.sqrt(d)) / (2 * a)
            return 1, raiz1 # indica que tem uma raiz e o valor dela
        else:
            if d < 0:
                return 0
            else:
                raiz1 = (-b + math.sqrt(d)) / (2 * a)
                raiz2 = (-b - math.sqrt(d)) / (2 * a)
                return 2, raiz1, raiz2

main()

main()

import Bhaskara

class TestBhaskara:

    def testa_uma_raiz(self):
        b = Bhaskara.Bhaskara()
        assert b.calcula_raizes(1, 0, 0) == (1, 0)

    def testa_duas_raizes(self):
        b = Bhaskara.Bhaskara()
        assert b.calcula_raizes(1, -5, 6) == (2, 3, 2)

    def testa_zero_raizes(self):
        b = Bhaskara.Bhaskara()
        assert b.calcula_raizes(10, 10, 10) == 0

    def testa_raiz_negativa(self):
        b = Bhaskara.Bhaskara()
        assert b.calcula_raizes(10, 20, 10) == (1, -1)


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Este código faz com que primeiramente toda a primeira linha seja preenchida, em seguida a segunda e assim sucessivamente. Se nós quiséssemos que a primeira coluna fosse preenchida e em seguida a segunda coluna e assim por diante, como ficaria o código?
Um exemplo: se o usuário digitasse o seguinte comando “x = cria_matriz(2,3)” e em seguida informasse os seis números para serem armazenados na matriz, na seguinte ordem: 1, 2, 3, 4, 5, 6; o x teria ao final da função a seguinte matriz: [[1, 3, 5], [2, 4, 6]].
Can you write Python code for it?

def cria_matriz(num_linhas, num_colunas):
    matriz = []  #lista vazia
    for i in range(num_linhas):
        linha = []
        for j in range(num_colunas):
            linha.append(0)
        matriz.append(linha)

    for i in range(num_colunas):
        for j in range(num_linhas):
            matriz[j][i] = int(input("Digite o elemento [" + str(j) + "][" + str(i) + "]: "))

    return matriz

x = cria_matriz(2, 3)

x

def tarefa(mat):
    dim = len(mat)
    for i in range(dim):
        print(mat[i][dim-1-i], end="  ")

mat = [[1,2,3],[4,5,6],[7,8,9]]
tarefa(mat)

# Observação: o trecho do print (end = " ") irá mudar a finalização padrão do print
# que é pular para a próxima linha. Com esta mudança, o cursor permanecerá na mesma
# linha aguardando a impressão seguinte.


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Exercício 1: Letras maiúsculas
Escreva a função maiusculas(frase) que recebe uma frase (uma string) como parâmetro e devolve uma string com as letras maiúsculas que existem nesta frase, na ordem em que elas aparecem.
Para resolver este exercício, pode ser útil verificar uma tabela ASCII, que contém os valores de cada caractere. Ver http://equipe.nce.ufrj.br/adriano/c/apostila/tabascii.htm
Note que para simplificar a solução do exercício, as frases passadas para a sua função não possuirão caracteres que não estejam presentes na tabela ASCII apresentada, como ç, á, É, ã, etc.
Dica: Os valores apresentados na tabela são os mesmos devolvidos pela função ord apresentada nas aulas.
Exemplos:
Can you write Python code for it?

maiusculas('Programamos em python 2?')
# deve devolver 'P'

maiusculas('Programamos em Python 3.')
# deve devolver 'PP'

maiusculas('PrOgRaMaMoS em python!')
# deve devolver 'PORMMS'

def maiusculas(frase):

    listRe = [] # lista de retorno vazia
    stringRe = '' # string de retorno vazia

    for ch in frase:
        if ord(ch) >=65 and ord(ch) <= 91:
            listRe.append(ch)

    # retornando a lista para string
    stringRe = ''.join(listRe)

    return stringRe

maiusculas('Programamos em python 2?')

maiusculas('Programamos em Python 3.')

maiusculas('PrOgRaMaMoS em python!')

x = ord('A')
y = ord('a')
x, y

ord('B')

ord('Z')


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Exercício 1: Tamanho da matriz
Escreva uma função dimensoes(matriz) que recebe uma matriz como parâmetro e imprime as dimensões da matriz recebida, no formato iXj.
Exemplos:
minha_matriz = [[1], [2], [3]]
dimensoes(minha_matriz)
3X1
minha_matriz = [[1, 2, 3], [4, 5, 6]]
dimensoes(minha_matriz)
2X3
Can you write Python code for it?

def dimensoes(A):

    '''Função que recebe uma matriz como parâmetro e imprime as dimensões da matriz recebida, no formato iXj.

    Obs: i = colunas, j = linhas

    Exemplo:
    >>> minha_matriz = [[1],
                        [2],
                        [3]
                        ]
    >>> dimensoes(minha_matriz)
    >>> 3X1
    '''

    lin = len(A)
    col = len(A[0])

    return print("%dX%d" % (lin, col))

matriz1 = [[1], [2], [3]]
dimensoes(matriz1)

matriz2 = [[1, 2, 3], [4, 5, 6]]
dimensoes(matriz2)


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Exercício 2: Encontrando ímpares em uma lista
Implemente a função encontra_impares(lista), que recebe como parâmetro uma lista de números inteiros e devolve uma outra lista apenas com os números ímpares da lista dada.
Sua solução deve ser implementada utilizando recursão.
Dica: você vai precisar do método extend() que as listas possuem.
Can you write Python code for it?

def encontra_impares_tradicional_way(lista):

    lista_impares = []

    for i in lista:
        if i % 2 != 0: # é impar!
            lista_impares.append(i)

    return lista_impares

a = [5, 66, 77, 99, 102, 239, 567, 875, 934]
encontra_impares_tradicional_way(a)

b = [2, 5, 34, 66, 100, 102, 999]
encontra_impares_tradicional_way(b)

stack = ['a','b']
stack.extend(['g','h'])
stack

def encontra_impares(lista):

    if len(lista) == 0:
        return []
    if lista[0] % 2 != 0: # se o elemento é impar
        return [lista[0]] + encontra_impares(lista[1:])
    else:
        return encontra_impares(lista[1:])

a = [5, 66, 77, 99, 102, 239, 567, 875, 934]
encontra_impares(a)

encontra_impares([5])

encontra_impares([1, 2, 3])

encontra_impares([2, 4, 6, 8])

encontra_impares([9])

encontra_impares([4, 11])

encontra_impares([2, 10, 20, 7, 30, 12, 6, 6])

encontra_impares([])

encontra_impares([4, 331, 1001, 4])


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Exercício 2: Matrizes multiplicáveis
Duas matrizes são multiplicáveis se o número de colunas da primeira é igual ao número de linhas da segunda. Escreva a função sao_multiplicaveis(m1, m2) que recebe duas matrizes como parâmetro e devolve True se as matrizes forem multiplicavéis (na ordem dada) e False caso contrário.
Exemplos:
m1 = [[1, 2, 3], [4, 5, 6]]
m2 = [[2, 3, 4], [5, 6, 7]]
sao_multiplicaveis(m1, m2) => False
m1 = [[1], [2], [3]]
m2 = [[1, 2, 3]]
sao_multiplicaveis(m1, m2) => True
Can you write Python code for it?

def sao_multiplicaveis(m1, m2):

    '''Recebe duas matrizes como parâmetros e devolve True se as matrizes forem multiplicáveis (número de colunas
    da primeira é igual ao número de linhs da segunda). False se não forem
    '''

    if len(m1) == len(m2[0]):
        return True
    else:
        return False

m1 = [[1, 2, 3], [4, 5, 6]]
m2 = [[2, 3, 4], [5, 6, 7]]
sao_multiplicaveis(m1, m2)

m1 = [[1], [2], [3]]
m2 = [[1, 2, 3]]
sao_multiplicaveis(m1, m2)


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Exercício 2: Menor nome
Como pedido no primeiro vídeo desta semana, escreva uma função menor_nome(nomes) que recebe uma lista de strings com nome de pessoas como parâmetro e devolve o nome mais curto presente na lista.
A função deve ignorar espaços antes e depois do nome e deve devolver o menor nome presente na lista. Este nome deve ser devolvido com a primeira letra maiúscula e seus demais caracteres minúsculos, independente de como tenha sido apresentado na lista passada para a função.
Quando houver mais de um nome com o menor comprimento dentre os nomes na lista, a função deve devolver o primeiro nome com o menor comprimento presente na lista.
Exemplos:
Can you write Python code for it?

menor_nome(['maria', 'josé', 'PAULO', 'Catarina'])
# deve devolver 'José'

menor_nome(['maria', ' josé  ', '  PAULO', 'Catarina  '])
# deve devolver 'José'

menor_nome(['Bárbara', 'JOSÉ  ', 'Bill'])
# deve devolver José

def menor_nome(nomes):

    tamanho = len(nomes) # pega a quantidade de nomes na lista
    menor = '' # variável para escolher o menor nome
    lista_limpa = [] # lista de nomes sem os espaços em branco

    # ignora espaços em branco
    for str in nomes:
        lista_limpa.append(str.strip())

    # verifica o menor nome
    menor = lista_limpa[0] # considera o primeiro como menor
    for str in lista_limpa:
        if len(str) < len(menor): # não deixei <= senão pegará um segundo menor de mesmo tamanho
            menor = str

    return menor.capitalize() # deixa a primeira letra maiúscula

menor_nome(['maria', 'josé', 'PAULO', 'Catarina'])
# deve devolver 'José'

menor_nome(['maria', ' josé  ', '  PAULO', 'Catarina  '])
# deve devolver 'José'

menor_nome(['Bárbara', 'JOSÉ  ', 'Bill'])
# deve devolver José

menor_nome(['Bárbara', 'JOSÉ  ', 'Bill', '     aDa '])


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Exercício 2: Ordem lexicográfica
Como pedido no segundo vídeo da semana, escreva a função primeiro_lex(lista) que recebe uma lista de strings como parâmetro e devolve o primeiro string na ordem lexicográfica. Neste exercício, considere letras maiúsculas e minúsculas.
Dica: revise a segunda vídeo-aula desta semana.
Exemplos:
primeiro_lex(['oĺá', 'A', 'a', 'casa'])
'A'
primeiro_lex(['AAAAAA', 'b'])
'AAAAAA'
Can you write Python code for it?

def primeiro_lex(lista):

    resposta = lista[0] # define o primeiro item da lista como a resposta...mas verifica depois.

    for str in lista:
        if ord(str[0]) < ord(resposta[0]):
            resposta = str

    return resposta

assert primeiro_lex(['oĺá', 'A', 'a', 'casa']), 'A'

assert primeiro_lex(['AAAAAA', 'b']), 'AAAAAA'

primeiro_lex(['casa', 'a', 'Z', 'A'])

primeiro_lex(['AAAAAA', 'b'])


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Exercício 2: Ordenação com selection sort
Implemente a função ordena(lista), que recebe uma lista com números inteiros como parâmetro e devolve esta lista ordenada. Utilize o algoritmo selection sort.
Can you write Python code for it?

def ordena(lista):

    fim = len(lista)

    for i in range(fim - 1):
        min = i

        for j in range(i + 1, fim):
            if lista[j] < lista[min]:
                min = j

        lista[i], lista[min] = lista[min], lista[i]

    return lista

lista = [10, 3, 8, -10, 200, 17, 32]
ordena(lista)
lista


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Exercício 2: Soma de matrizes
Escreva a função soma_matrizes(m1, m2) que recebe 2 matrizes e devolve uma matriz que represente sua soma caso as matrizes tenham dimensões iguais. Caso contrário, a função deve devolver False.
Exemplos:
m1 = [[1, 2, 3], [4, 5, 6]]
m2 = [[2, 3, 4], [5, 6, 7]]
soma_matrizes(m1, m2) => [[3, 5, 7], [9, 11, 13]]
m1 = [[1], [2], [3]]
m2 = [[2, 3, 4], [5, 6, 7]]
soma_matrizes(m1, m2) => False
Can you write Python code for it?

def soma_matrizes(m1, m2):

    def dimensoes(A):
        lin = len(A)
        col = len(A[0])

        return ((lin, col))

    if dimensoes(m1) != dimensoes(m2):
        return False
    else:
        matriz = []
        for i in range(len(m1)):
            linha = []
            for j in range(len(m1[0])):
                linha.append(m1[i][j] + m2[i][j])
            matriz.append(linha)
        return matriz

m1 = [[1, 2, 3], [4, 5, 6]]
m2 = [[2, 3, 4], [5, 6, 7]]
soma_matrizes(m1, m2)

m1 = [[1], [2], [3]]
m2 = [[2, 3, 4], [5, 6, 7]]
soma_matrizes(m1, m2)


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Exercício 2: Triângulos semelhantes
Ainda na classe Triangulo, escreva um método semelhantes(triangulo)
que recebe um objeto do tipo Triangulo como parâmetro e verifica
se o triângulo atual é semelhante ao triângulo passado como parâmetro.
Caso positivo, o método deve devolver True. Caso negativo,
deve devolver False.
Verifique a semelhança dos triângulos através do comprimento
dos lados.
Dica: você pode colocar os lados de cada um dos triângulos em uma
lista diferente e ordená-las.
Exemplo:
t1 = Triangulo(2, 2, 2)
t2 = Triangulo(4, 4, 4)
t1.semelhantes(t2)
deve devolver True
'''
Can you write Python code for it?

class Triangulo:

    '''
    O resultado dos testes com seu programa foi:

    ***** [0.2 pontos]: Testando método semelhantes(Triangulo(3, 4, 5)) para Triangulo(3, 4, 5) - Falhou *****
    TypeError: 'Triangulo' object is not iterable

    ***** [0.2 pontos]: Testando método semelhantes(Triangulo(3, 4, 5)) para Triangulo(6, 8, 10) - Falhou *****
    TypeError: 'Triangulo' object is not iterable

    ***** [0.2 pontos]: Testando método semelhantes(Triangulo(6, 8, 10)) para Triangulo(3, 4, 5) - Falhou *****
    TypeError: 'Triangulo' object is not iterable

    ***** [0.4 pontos]: Testando método semelhantes(Triangulo(3, 3, 3)) para Triangulo(3, 4, 5) - Falhou *****
    TypeError: 'Triangulo' object is not iterable

    '''
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c

# https://stackoverflow.com/questions/961048/get-class-that-defined-method
    def semelhantes(self, Triangulo):

        list1 = []

        for arg in self:
            list1.append(arg)

        list2 = []

        for arg in self1:
            list2.append(arg)

        for i in list2:
            print(i)

t1 = Triangulo(2, 2, 2)
t2 = Triangulo(4, 4, 4)
t1.semelhantes(t2)


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Exercícios

Escreva uma versão do TestaBhaskara usando @pytest.mark.parametrize

Escreva uma bateria de testes para o seu código preferido

Tarefa de programação: Lista de exercícios - 3
Exercício 1: Uma classe para triângulos
Defina a classe Triangulo cujo construtor recebe 3 valores inteiros correspondentes aos lados a, b e c de um triângulo.
A classe triângulo também deve possuir um método perimetro, que não recebe parâmetros e devolve um valor inteiro correspondente ao perímetro do triângulo.
t = Triangulo(1, 1, 1)
deve atribuir uma referência para um triângulo de lados 1, 1 e 1 à variável t
Um objeto desta classe deve responder às seguintes chamadas:
t.a
deve devolver o valor do lado a do triângulo
t. b
deve devolver o valor do lado b do triângulo
t.c
deve devolver o valor do lado c do triângulo
t.perimetro()
deve devolver um inteiro correspondente ao valor do perímetro do triângulo.
Can you write Python code for it?

class Triangulo:

    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c

    def perimetro(self):
        return self.a + self.b + self.c

t = Triangulo(1, 1, 1)

t.a

t.b

t.c

t.perimetro()


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Incluindo
print(__name__)
 na última linha de fibo.py, ao fazer a importação import fibo no shell do Python, imprime 'fibo', que é o nome do programa.
Ao incluir

if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))

podemos ver se está sendo executado como script (com o if do jeito que está) ou como módulo dentro de outro código (se o nome não for main, está sendo importado pra usar alguma função lá dentro).
Can you write Python code for it?

def fazAlgo(string): # inverte a string e deixa as vogais maiúsculas
    pos = len(string)-1 # define a variável posição do array
    stringMi = string.lower() # aqui estão todas minúsculas
    string = string.upper() # aqui estão todas maiúsculas
    stringRe = "" # string de retorno

    while pos >= 0:
        if string[pos] == 'A' or string[pos] == 'E' or string[pos] == 'I' or string[pos] == 'O' or string[pos] == 'U':
            stringRe = stringRe + string[pos]
        else:
            stringRe = stringRe + stringMi[pos]
        pos = pos - 1
    return stringRe

if __name__ == "__main__":
    print(fazAlgo("teste"))
    print(fazAlgo("o ovo do avestruz"))
    print(fazAlgo("A CASA MUITO ENGRAÇADA"))
    print(fazAlgo("A TELEvisão queBROU"))
    print(fazAlgo("A Vaca Amarela"))


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Melhoria no Algoritmo de Ordenação da Bolha
Percorre a lista múltiplas vezes; a cada passagem, compara todos os elementos adjacentes e troca de lugar os que estiverem fora de ordem.
Melhoria: se em uma das iterações, nenhuma troca é realizada, isso significa que a lista já está ordenada e podemos finalizar o algoritmo.
Can you write Python code for it?

class Ordenador:

    def selecao_direta(self, lista):

        fim = len(lista)

        for i in range(fim - 1):
            # Inicialmente o menor elemento já visto é o i-ésimo
            posicao_do_minimo = i

            for j in range(i + 1, fim):
                if lista[j] < lista[posicao_do_minimo]: # encontrou um elemento menor...
                    posicao_do_minimo = j               # ...substitui.

            # Coloca o menor elemento encontrado no início da sub-lista
            # Para isso, troca de lugar os elementos nas posições i e posicao_do_minimo

            lista[i], lista[posicao_do_minimo] = lista[posicao_do_minimo], lista[i]

    def bolha(self, lista):

        fim = len(lista)

        for i in range(fim - 1, 0, -1):
            for j in range(i):
                if lista[j] > lista[j + 1]:
                    lista[j], lista[j + 1] = lista[j + 1], lista[j]

    def bolha_curta(self, lista):

        fim = len(lista)

        for i in range(fim - 1, 0, -1):
            trocou = False
            for j in range(i):
                if lista[j] > lista[j + 1]:
                    lista[j], lista[j + 1] = lista[j + 1], lista[j]
                    trocou = True
            if not trocou: # que é igual a if trocou == False
                return

import random
import time

class ContaTempos:

    def lista_aleatoria(self, n): # n = número de elementos da lista
        from random import randrange
        lista = [random.randrange(1000) for x in range(n)] # lista com n elementos, todos sendo aleatórios de 0 a 999
        return lista

    def lista_quase_ordenada(self, n):
        lista = [x for x in range(n)] # lista ordenada
        lista[n//10] = -500 # localizou o -500 no primeiro décimo da lista
        return lista

    def compara(self, n):

        lista1 = self.lista_aleatoria(n)
        lista2 = lista1
        lista3 = lista2

   ...


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Mergesort
Ordenação por Intercalação:

Divida a lista na metade recursivamente, até que cada sublista contenha apenas 1 elemento (portanto, já ordenada).

Repetidamente, intercale as sublistas para produzir novas listas ordenadas.

Repita até que tenhamos apenas 1 lista no final (que estará ordenada).

Ex:
6 5 3 1 8 7 2 4
5 6    1 3    7 8    2 4
1 3 5 6    2 4 7 8
1 2 3 4 5 6 7 8
Can you write Python code for it?

def merge_sort(lista):
    if len(lista) <= 1:
        return lista

    meio = len(lista) // 2

    lado_esquerdo = merge_sort(lista[:meio])
    lado_direito = merge_sort(lista[meio:])

    return merge(lado_esquerdo, lado_direito) # intercala os dois lados

def merge(lado_esquerdo, lado_direito):
    if not lado_esquerdo: # se o lado esquerdo for uma lista vazia...
        return lado_direito

    if not lado_direito: # se o lado direito for uma lista vazia...
        return lado_esquerdo

    if lado_esquerdo[0] < lado_direito[0]: # compara o primeiro elemento da posição do lado esquerdo com o primeiro do lado direito
        return [lado_esquerdo[0]] + merge(lado_esquerdo[1:], lado_direito) # merge(lado_esquerdo[1:]) ==> pega o lado esquerdo, menos o primeiro elemento

    return [lado_direito[0]] + merge(lado_esquerdo, lado_direito[1:])


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
POO – Programação Orientada a Objetos – Parte 2
Can you write Python code for it?

def main():
    carro1 = Carro('Brasília', 1968, 'amarela', 80)
    carro2 = Carro('Fuscão', 1981, 'preto', 95)

    carro1.acelere(40)
    carro2.acelere(50)
    carro1.acelere(80)
    carro1.pare()
    carro2.acelere(100)

class Carro:

    def __init__(self, modelo, ano, cor, vel_max):
        self.modelo = modelo
        self.ano    = ano
        self.cor    = cor
        self.vel    = 0
        self.maxV   = vel_max # velocidade máxima

    def imprima(self):
        if self.vel == 0: # parado dá para ver o ano
            print('%s %s %d' % (self.modelo, self.cor, self.ano))
        elif self.vel < self.maxV:
            print('%s %s indo a %d km/h' % (self.modelo, self.cor, self.vel))
        else:
            print('%s %s indo muito rapido!' % (self.modelo, self.cor))

    def acelere(self, velocidade):
        self.vel = velocidade
        if self.vel > self.maxV:
            self.vel = self.maxV
        self.imprima()

    def pare(self):
        self.vel = 0
        self.imprima()

main()


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Parametrização
Can you write Python code for it?

def fatorial(n):
    if n < 0:
        return 0
    i = fat = 1
    while i <= n:
        fat = fat * i
        i += 1
    return fat

import pytest

@pytest.mark.parametrize("entrada, esperado", [
    (0, 1),
    (1, 1),
    (-10, 0),
    (4, 24),
    (5, 120)
    ])

def testa_fatorial(entrada, esperado):
    assert fatorial(entrada) == esperado


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Praticar tarefa de programação: Exercícios adicionais (opcionais)
Exercício 1: Gerando listas grandes
Escreva a função lista_grande(n), que recebe como parâmetro um número inteiro n e devolve uma lista contendo n números inteiros aleatórios.
Can you write Python code for it?

def lista_grande(n):

    import random
    return random.sample(range(1, 1000), n)

lista_grande(10)


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
TESTE PARA PRATICAR POO – Programação Orientada a Objetos – Parte 2
Can you write Python code for it?

class Cafeteira:
  def __init__(self, marca, tipo, tamanho, cor):
    self.marca = marca
    self.tipo = tipo
    self.tamanho = tamanho
    self.cor = cor

class Cachorro:
  def __init__(self, raça, idade, nome, cor):
    self.raça = raça
    self.idade = idade
    self.nome = nome
    self.cor = cor

rex = Cachorro('vira-lata', 2, 'Bobby', 'marrom')

'vira-lata' == rex.raça

rex.idade > 2

rex.idade == '2'

rex.nome == 'rex'

Bobby.cor == 'marrom'

rex.cor == 'marrom'

class Lista:
  def append(self, elemento):
    return "Oops! Este objeto não é uma lista"

lista = []

a = Lista()
b = a.append(7)

lista.append(b)

a

b

lista


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Tarefa de programação: Lista de exercícios - 4
Exercício 1: Lista ordenada
Escreva a função ordenada(lista), que recebe uma lista com números inteiros como parâmetro e devolve o booleano True se a lista estiver ordenada e False se a lista não estiver ordenada.
Can you write Python code for it?

def ordenada(list):

    flag = True

    for i in range(len(list) - 1):
        if list[i] > list[i + 1]:
            flag = False

    return flag


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Testes para praticar
Can you write Python code for it?

class Pato:
  pass

pato = Pato()
patinho = Pato()
if pato == patinho:
  print("Estamos no mesmo endereço!")
else:
  print("Estamos em endereços diferentes!")

class Carro:
    def __init__(self, modelo, ano, cor): # init é o Construtor da classe
        self.modelo = modelo
        self.ano = ano
        self.cor = cor

carro_do_meu_avo = Carro('Ferrari', 1980, 'vermelha')
carro_do_meu_avo

carro_do_meu_avo.cor


I am working on the file "Coursera/CICCP2/.ipynb_checkpoints/Curso Introdução à Ciência da Computação com Python - Parte 2-checkpoint.ipynb".
The first task is:
Week 5 - Algoritmo de Ordenação da Bolha - Bubblesort
Lista como um tubo de ensaio vertical, os elementos mais leves sobem à superfície como uma bolha, os mais pesados afundam.
Percorre a lista múltiplas vezes; a cada passagem, compara todos os elementos adjacentes e troca de lugar os que estiverem fora de ordem
Can you write Python code for it?

class Ordenador:

    def selecao_direta(self, lista):

        fim = len(lista)

        for i in range(fim - 1):
            # Inicialmente o menor elemento já visto é o i-ésimo
            posicao_do_minimo = i

            for j in range(i + 1, fim):
                if lista[j] < lista[posicao_do_minimo]: # encontrou um elemento menor...
                    posicao_do_minimo = j               # ...substitui.

            # Coloca o menor elemento encontrado no início da sub-lista
            # Para isso, troca de lugar os elementos nas posições i e posicao_do_minimo

            lista[i], lista[posicao_do_minimo] = lista[posicao_do_minimo], lista[i]

    def bolha(self, lista):

        fim = len(lista)

        for i in range(fim - 1, 0, -1):
            for j in range(i):
                if lista[j] > lista[j + 1]:
                    lista[j], lista[j + 1] = lista[j + 1], lista[j]


I am working on the file "Coursera/CICCP2/Curso Introdução à Ciência da Computação com Python - Parte 2.ipynb".
The first task is:
Busca Binária
Objetivo: localizar o elemento x em uma lista

Considere o elemento m do meio da lista
se x == m ==> encontrou!
se x < m ==> procure apenas na 1ª metade (da esquerda)
se x > m ==> procure apenas na 2ª metade (da direita),
repetir o processo até que o x seja encontrado ou que a sub-lista em questão esteja vazia
Can you write Python code for it?

class Buscador:

    def busca_por_titulo(self, playlist, titulo):
        for i in range(len(playlist)):
            if playlist[i].titulo == titulo:
                return i
        return -1

    def busca_binaria(self, lista, x):
        primeiro = 0
        ultimo = len(lista) - 1

        while primeiro <= ultimo:
            meio = (primeiro + ultimo) // 2
            if lista[meio] == x:
                return meio
            else:
                if x < lista[meio]: # busca na primeira metade da lista
                    ultimo = meio - 1 # já foi visto que não está no elemento meio, então vai um a menos
                else:
                    primeiro = meio + 1
        return -1

lista = [-100, 0, 20, 30, 50, 100, 3000, 5000]
b = Buscador()
b.busca_binaria(lista, 30)


I am working on the file "Coursera/CICCP2/Curso Introdução à Ciência da Computação com Python - Parte 2.ipynb".
The first task is:
Comparação de Desempenho
Módulo time:

função time()
devolve o tempo decorrido (em segundos) desde 1/1/1970 (no Unix)

Para medir um intervalo de tempo
import time
antes = time.time()
algoritmo_a_ser_cronometrado()
depois = time.time()
print("A execução do algoritmo demorou ", depois - antes, "segundos")
Can you write Python code for it?

class Ordenador:

    def selecao_direta(self, lista):

        fim = len(lista)

        for i in range(fim - 1):
            # Inicialmente o menor elemento já visto é o i-ésimo
            posicao_do_minimo = i

            for j in range(i + 1, fim):
                if lista[j] < lista[posicao_do_minimo]: # encontrou um elemento menor...
                    posicao_do_minimo = j               # ...substitui.

            # Coloca o menor elemento encontrado no início da sub-lista
            # Para isso, troca de lugar os elementos nas posições i e posicao_do_minimo

            lista[i], lista[posicao_do_minimo] = lista[posicao_do_minimo], lista[i]

    def bolha(self, lista):

        fim = len(lista)

        for i in range(fim - 1, 0, -1):
            for j in range(i):
                if lista[j] > lista[j + 1]:
                    lista[j], lista[j + 1] = lista[j + 1], lista[j]

import random
import time

class ContaTempos:

    def lista_aleatoria(self, n): # n = número de elementos da lista
        from random import randrange
        lista = [0 for x in range(n)] # lista com n elementos, todos sendo zero
        for i in range(n):
            lista[i] = random.randrange(1000) # inteiros entre 0 e 999
        return lista

    def compara(self, n):

        lista1 = self.lista_aleatoria(n)
        lista2 = lista1

        o = Ordenador()

        antes = time.time()
        o.bolha(lista1)
        depois = time.time()
        print("Bolha demorou", depois - antes, "segundos")

        antes = time.time()
        o.selecao_direta(lista2)
        depois = time.time()
        print("Seleção direta demorou", depois - antes, "segundos")

c = ContaTempos()
c.compara(1000)

print("Diferença de", 0.16308164596557617 - 0.05245494842529297)

c.compara(5000)


I am working on the file "Coursera/CICCP2/Curso Introdução à Ciência da Computação com Python - Parte 2.ipynb".
The first task is:
Complexidade Computacional

Análise matemática do desempenho de um algoritmo

Estudo analítico de:

Quantas operações um algoritmo requer para que ele seja executado
Quanto tempo ele vai demorar para ser executado
Quanto de memória ele vai ocupar

Análise da Busca Sequencial
Exemplo:
Lista telefônica de São Paulo, supondo 2 milhões de telefones fixos.
Supondo que cada iteração do for comparação de string dure 1 milissegundo.
Pior caso: 2000s = 33,3 minutos
Caso médio (1 milhão): 1000s = 16,6 minutos
Complexidade Computacional da Busca Sequencial

Dada uma lista de tamanho n

A complexidade computacional da busca sequencial é:

n, no pior caso
n/2, no caso médio

Conclusão

Busca sequencial é boa pois é bem simples

Funciona bem quando a busca é feita num volume pequeno de dados

Sua Complexidade Computacional é muito alta

É muito lenta quando o volume de dados é grande
Portanto, dizemos que é um algoritmo ineficiente

Algoritmo de Ordenação Seleção Direta
Seleção Direta
A cada passo, busca pelo menor elemento do pedaço ainda não ordenado da lista e o coloca no início da lista
No 1º passo, busca o menor elemento de todos e coloca na posição inicial da lista.
No 2º passo, busca o 2º menor elemento da lista e coloca na 2ª posição da lista.
No 3º passo, busca o 3º menor elemento da lista e coloca na 3ª posição da lista.
Repete até terminar a lista
Can you write Python code for it?

class Ordenador:

    def selecao_direta(self, lista):

        fim = len(lista)

        for i in range(fim - 1):
            # Inicialmente o menor elemento já visto é o i-ésimo
            posicao_do_minimo = i

            for j in range(i + 1, fim):
                if lista[j] < lista[posicao_do_minimo]: # encontrou um elemento menor...
                    posicao_do_minimo = j               # ...substitui.

            # Coloca o menor elemento encontrado no início da sub-lista
            # Para isso, troca de lugar os elementos nas posições i e posicao_do_minimo

            lista[i], lista[posicao_do_minimo] = lista[posicao_do_minimo], lista[i]

lista = [10, 3, 8, -10, 200, 17, 32]
o = Ordenador()

o.selecao_direta(lista)

lista

lista_nomes = ['maria', 'carlos', 'wilson', 'ana']
o.selecao_direta(lista_nomes)
lista_nomes

import random

print(random.randint(1, 10))

from random import shuffle
x = [i for i in range(100)]
shuffle(x)
x

o.selecao_direta(x)
x

def comprova_ordem(list):

    flag = True

    for i in range(len(list) - 1):
        if list[i] > list[i + 1]:
            flag = False

    return flag

comprova_ordem(x)

list = [1, 2, 3, 4, 5]
list2 = [1, 3, 2, 4, 5]

comprova_ordem(list)

comprova_ordem(list2)

def busca_sequencial(seq, x):
    for i in range(len(seq)):
        if seq[i] == x:
            return True
    return False

def selecao_direta(lista):
    fim = len(lista)
    for i in range(fim-1):
        pos_menor = i
        for j in range(i+1,fim):
            if lista[j] < lista[pos_menor]:
                pos_menor = j
        lista[i],lista[pos_menor] = lista[pos_menor],lista[i]
    return lista

numeros = [55,33,0,900,-432,10,77,2,11]


I am working on the file "Coursera/CICCP2/Curso Introdução à Ciência da Computação com Python - Parte 2.ipynb".
The first task is:
Complexidade da Busca Binária
Dado uma lista de n elementos
No pior caso, teremos que efetuar:
$$log_2n$$ comparações
No exemplo da lista telefônica (com 2 milhões de números):
$$log_2(2 milhões) = 20,9$$
Portanto: resposta em menos de 21 milissegundos!
Conclusão

Busca Binária é um algoritmo bastante eficiente

Ao estudar a eficiência de um algoritmo é interessante:

Analisar a complexidade computacional
Realizar experimentos medindo o desempenho

Tarefa de programação: Lista de exercícios - 5
Exercício 1: Busca binária
Implemente a função busca(lista, elemento), que busca um determinado elemento em uma lista e devolve o índice correspondente à posição do elemento encontrado. Utilize o algoritmo de busca binária. Nos casos em que o elemento buscado não existir na lista, a função deve devolver o booleano False.
Além de devolver o índice correspondente à posição do elemento encontrado, sua função deve imprimir cada um dos índices testados pelo algoritmo.
Exemplo:
busca(['a', 'e', 'i'], 'e')
1
deve devolver => 1
busca([1, 2, 3, 4, 5], 6)
2
3
4
deve devolver => False
busca([1, 2, 3, 4, 5, 6], 4)
2
4
3
deve devolver => 3
Can you write Python code for it?

def busca(lista, elemento):

    primeiro = 0
    ultimo = len(lista) - 1

    while primeiro <= ultimo:
        meio = (primeiro + ultimo) // 2
        if lista[meio] == elemento:
            print(meio)
            return meio
        else:
            if elemento < lista[meio]: # busca na primeira metade da lista
                ultimo = meio - 1 # já foi visto que não está no elemento meio, então vai um a menos
                print(meio) # função deve imprimir cada um dos índices testados pelo algoritmo.
            else:
                primeiro = meio + 1
                print(meio)
    return False

busca(['a', 'e', 'i'], 'e')

busca([1, 2, 3, 4, 5], 6)

busca([1, 2, 3, 4, 5, 6], 4)


I am working on the file "Coursera/CICCP2/Curso Introdução à Ciência da Computação com Python - Parte 2.ipynb".
The first task is:
Este código faz com que primeiramente toda a primeira linha seja preenchida, em seguida a segunda e assim sucessivamente. Se nós quiséssemos que a primeira coluna fosse preenchida e em seguida a segunda coluna e assim por diante, como ficaria o código?
Um exemplo: se o usuário digitasse o seguinte comando “x = cria_matriz(2,3)” e em seguida informasse os seis números para serem armazenados na matriz, na seguinte ordem: 1, 2, 3, 4, 5, 6; o x teria ao final da função a seguinte matriz: [[1, 3, 5], [2, 4, 6]].
Can you write Python code for it?

def cria_matriz(num_linhas, num_colunas):
    matriz = []  #lista vazia
    for i in range(num_linhas):
        linha = []
        for j in range(num_colunas):
            linha.append(0)
        matriz.append(linha)

    for i in range(num_colunas):
        for j in range(num_linhas):
            matriz[j][i] = int(input("Digite o elemento [" + str(j) + "][" + str(i) + "]: "))

    return matriz

x = cria_matriz(2, 3)

x

def tarefa(mat):
    dim = len(mat)
    for i in range(dim):
        print(mat[i][dim-1-i], end="  ")

mat = [[1,2,3],[4,5,6],[7,8,9]]
tarefa(mat)

# Observação: o trecho do print (end = " ") irá mudar a finalização padrão do print
# que é pular para a próxima linha. Com esta mudança, o cursor permanecerá na mesma
# linha aguardando a impressão seguinte.


I am working on the file "Coursera/CICCP2/Curso Introdução à Ciência da Computação com Python - Parte 2.ipynb".
The first task is:
Exercício
Escrever uma função que recebe uma lista de Strings contendo nomes de pessoas como parâmetro e devolve o nome mais curto. A função deve ignorar espaços antes e depois do nome e deve devolver o nome com a primeira letra maiúscula.
Can you write Python code for it?

def mais_curto(lista_de_nomes):

    menor = lista_de_nomes[0] # considerando que o menor nome está no primeiro lugar

    for i in lista_de_nomes:
        if len(i) < len(menor):
            menor = i

    return menor.capitalize()

lista = ['carlos', 'césar', 'ana', 'vicente', 'maicon', 'washington']

mais_curto(lista)

ord('a')

ord('A')

ord('b')

ord('m')

ord('M')

ord('AA')

'maçã' > 'banana'

'Maçã' > 'banana'

'Maçã'.lower() > 'banana'.lower()

txt = 'José'
txt = txt.lower()
txt

lista = ['ana', 'maria', 'José', 'Valdemar']
len(lista)

lista[3].lower()

lista[2]

lista[2] = lista[2].lower()

lista

for i in lista:
    print(i)

lista[0][0]


I am working on the file "Coursera/CICCP2/Curso Introdução à Ciência da Computação com Python - Parte 2.ipynb".
The first task is:
Exercício 1: Letras maiúsculas
Escreva a função maiusculas(frase) que recebe uma frase (uma string) como parâmetro e devolve uma string com as letras maiúsculas que existem nesta frase, na ordem em que elas aparecem.
Para resolver este exercício, pode ser útil verificar uma tabela ASCII, que contém os valores de cada caractere. Ver http://equipe.nce.ufrj.br/adriano/c/apostila/tabascii.htm
Note que para simplificar a solução do exercício, as frases passadas para a sua função não possuirão caracteres que não estejam presentes na tabela ASCII apresentada, como ç, á, É, ã, etc.
Dica: Os valores apresentados na tabela são os mesmos devolvidos pela função ord apresentada nas aulas.
Exemplos:
Can you write Python code for it?

maiusculas('Programamos em python 2?')
# deve devolver 'P'

maiusculas('Programamos em Python 3.')
# deve devolver 'PP'

maiusculas('PrOgRaMaMoS em python!')
# deve devolver 'PORMMS'

def maiusculas(frase):

    listRe = [] # lista de retorno vazia
    stringRe = '' # string de retorno vazia

    for ch in frase:
        if ord(ch) >=65 and ord(ch) <= 91:
            listRe.append(ch)

    # retornando a lista para string
    stringRe = ''.join(listRe)

    return stringRe

maiusculas('Programamos em python 2?')

maiusculas('Programamos em Python 3.')

maiusculas('PrOgRaMaMoS em python!')

x = ord('A')
y = ord('a')
x, y

ord('B')

ord('Z')


I am working on the file "Coursera/CICCP2/Curso Introdução à Ciência da Computação com Python - Parte 2.ipynb".
The first task is:
Exercício 2: Busca sequencial
Implemente a função busca(lista, elemento), que busca um determinado elemento em uma lista e devolve o índice correspondente à posição do elemento encontrado. Utilize o algoritmo de busca sequencial. Nos casos em que o elemento buscado não existir na lista, a função deve devolver o booleano False.
busca(['a', 'e', 'i'], 'e')
deve devolver => 1
busca([12, 13, 14], 15)
deve devolver => False
Can you write Python code for it?

def busca(lista, elemento):

    for i in range(len(lista)):
        if lista[i] == elemento:
            return i
    return False

busca(['a', 'e', 'i'], 'e')

busca([12, 13, 14], 15)