From fe97c98971787de2d6d89ed00bcdc3c0fa33a485 Mon Sep 17 00:00:00 2001 From: Laura Date: Thu, 16 Mar 2023 14:39:06 -0700 Subject: [PATCH 01/10] add a sentence in the README file --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index cfaa5310..b7e50222 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,7 @@ # AdaGrams +First project! + ## Skills Assessed - Following directions and reading comprehension From b12bf2213437419e87cbc7ca708f5e99d6cfc0fa Mon Sep 17 00:00:00 2001 From: Laura Date: Fri, 17 Mar 2023 06:32:12 -0700 Subject: [PATCH 02/10] create draw_letters function --- adagrams/game.py | 60 ++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 53 insertions(+), 7 deletions(-) diff --git a/adagrams/game.py b/adagrams/game.py index 5fb37b11..75edb289 100644 --- a/adagrams/game.py +++ b/adagrams/game.py @@ -1,11 +1,57 @@ +import random +LETTER_POOL = { + 'A': 9, + 'B': 2, + 'C': 2, + 'D': 4, + 'E': 12, + 'F': 2, + 'G': 3, + 'H': 2, + 'I': 9, + 'J': 1, + 'K': 1, + 'L': 4, + 'M': 2, + 'N': 6, + 'O': 8, + 'P': 2, + 'Q': 1, + 'R': 6, + 'S': 4, + 'T': 6, + 'U': 4, + 'V': 2, + 'W': 2, + 'X': 1, + 'Y': 2, + 'Z': 1 +} def draw_letters(): - pass + + # create a new pool of letters (every letter is there as many times as the value of the dic indicates) + letters = [] + for k, v in LETTER_POOL.items(): + letter_times = k * v + letters.append(letter_times) + big_string = ''.join(letters) + + # select letters (random) + selected_letters = [] + + for i in range(0,10): + letter_for_list = random.choice(big_string) + selected_letters.append(letter_for_list) + index = big_string.index(letter_for_list) + big_string = big_string[:index]+ big_string[index+1:] + + return selected_letters -def uses_available_letters(word, letter_bank): - pass +# def uses_available_letters(word, letter_bank): +# pass -def score_word(word): - pass +# def score_word(word): +# pass -def get_highest_word_score(word_list): - pass \ No newline at end of file +# def get_highest_word_score(word_list): +# pass \ No newline at end of file From ac42714d06122e7ba37e792f2e4f4b6107e54ad7 Mon Sep 17 00:00:00 2001 From: Laura Date: Fri, 17 Mar 2023 09:57:04 -0700 Subject: [PATCH 03/10] check for letters in bank and ignores case --- adagrams/game.py | 39 +++++++++++++++++++++++++++++++++++++-- tests/test_wave_02.py | 14 ++++++++++---- 2 files changed, 47 insertions(+), 6 deletions(-) diff --git a/adagrams/game.py b/adagrams/game.py index 75edb289..546a2628 100644 --- a/adagrams/game.py +++ b/adagrams/game.py @@ -47,8 +47,43 @@ def draw_letters(): return selected_letters -# def uses_available_letters(word, letter_bank): -# pass +# hand = ['Y', 'V', 'B', 'U', 'A', 'P', 'E', 'R', 'K', 'R'] + + +def uses_available_letters(word, letter_bank): + # hay que contar cuantas veces la usa también (analizar el letter bank) + # tiene que ver que no sea igual que el letter bank + # hay que pasar el input a mayusculas + + # correct input + new = word.upper() + # check for new letters in bank and check doesnt copy letter bank + for letter in new: + if letter not in letter_bank: + return False + count_letters_in_bank = {} + for letter in letter_bank: + if letter not in count_letters_in_bank: + count_letters_in_bank[letter] = 1 + else: + count_letters_in_bank[letter] += 1 + count_letters_in_new = {} + for letter in new: + if letter not in count_letters_in_new: + count_letters_in_new[letter] = 1 + else: + count_letters_in_new[letter] += 1 + for k, v in count_letters_in_new.items(): + for key, value in count_letters_in_bank.items(): + if k == key: + if v <= value: + + return True + else: + return False + + + # def score_word(word): # pass diff --git a/tests/test_wave_02.py b/tests/test_wave_02.py index a5170d8a..5ee8910b 100644 --- a/tests/test_wave_02.py +++ b/tests/test_wave_02.py @@ -2,6 +2,7 @@ from adagrams.game import uses_available_letters +# pasó reconocer que está en el letter bank def test_uses_available_letters_true_word_in_letter_bank(): # Arrange letters = ["D", "O", "G", "X", "X", "X", "X", "X", "X", "X"] @@ -13,6 +14,7 @@ def test_uses_available_letters_true_word_in_letter_bank(): # Assert assert is_valid == True + def test_uses_available_letters_false_word_in_letter_bank(): # Arrange letters = ["D", "O", "X", "X", "X", "X", "X", "X", "X", "X"] @@ -24,6 +26,8 @@ def test_uses_available_letters_false_word_in_letter_bank(): # Assert assert is_valid == False +# pasó contar la cantidad de veces que se usa cada letra + def test_uses_available_letters_false_word_overuses_letter(): # Arrange letters = ["A", "X", "X", "X", "X", "X", "X", "X", "X", "X"] @@ -35,6 +39,7 @@ def test_uses_available_letters_false_word_overuses_letter(): # Assert assert is_valid == False +@pytest.mark.skip(reason="no way of currently testing this") def test_uses_available_letters_does_not_change_letter_bank(): # Arrange letters = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"] @@ -48,12 +53,13 @@ def test_uses_available_letters_does_not_change_letter_bank(): assert is_valid == True assert letters == letters_copy +# paso mayusculas: def test_uses_available_letters_ignores_case(): # Arrange letters = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"] # Act/Assert - assert uses_available_letters("bEd", letters) - assert uses_available_letters("fad", letters) - assert uses_available_letters("a", letters) - assert not uses_available_letters("aA", letters) \ No newline at end of file + assert uses_available_letters("bEd", letters), "Test1" + assert uses_available_letters("fad", letters),"Test2" + assert uses_available_letters("a", letters), "Test3" + assert not uses_available_letters("aA", letters), "Test4" \ No newline at end of file From 404bedf46e677c34fdf39b8b4a66a4404b60473f Mon Sep 17 00:00:00 2001 From: Laura Date: Fri, 17 Mar 2023 12:13:08 -0700 Subject: [PATCH 04/10] write uses available letters --- adagrams/game.py | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/adagrams/game.py b/adagrams/game.py index 546a2628..d508393f 100644 --- a/adagrams/game.py +++ b/adagrams/game.py @@ -47,13 +47,8 @@ def draw_letters(): return selected_letters -# hand = ['Y', 'V', 'B', 'U', 'A', 'P', 'E', 'R', 'K', 'R'] - def uses_available_letters(word, letter_bank): - # hay que contar cuantas veces la usa también (analizar el letter bank) - # tiene que ver que no sea igual que el letter bank - # hay que pasar el input a mayusculas # correct input new = word.upper() @@ -73,11 +68,12 @@ def uses_available_letters(word, letter_bank): count_letters_in_new[letter] = 1 else: count_letters_in_new[letter] += 1 + for k, v in count_letters_in_new.items(): for key, value in count_letters_in_bank.items(): if k == key: if v <= value: - + print(f"value {value}") return True else: return False From dff43bc3790fff328a3d46b064aa47c39ebbf2d5 Mon Sep 17 00:00:00 2001 From: Laura Date: Fri, 17 Mar 2023 12:48:04 -0700 Subject: [PATCH 05/10] write score_word --- adagrams/game.py | 43 +++++++++++++++++++++++++++++++++++++++---- 1 file changed, 39 insertions(+), 4 deletions(-) diff --git a/adagrams/game.py b/adagrams/game.py index d508393f..54a610ca 100644 --- a/adagrams/game.py +++ b/adagrams/game.py @@ -79,10 +79,45 @@ def uses_available_letters(word, letter_bank): return False - - -# def score_word(word): -# pass +def score_word(word): + score_values = { + 'A': 1, + 'B': 3, + 'C': 3, + 'D': 2, + 'E': 1, + 'F': 4, + 'G': 2, + 'H': 4, + 'I': 1, + 'J': 8, + 'K': 5, + 'L': 1, + 'M': 3, + 'N': 1, + 'O': 1, + 'P': 3, + 'Q': 10, + 'R': 1, + 'S': 1, + 'T': 1, + 'U': 1, + 'V': 4, + 'W': 4, + 'X': 8, + 'Y': 4, + 'Z': 10 +} + word_upper = word.upper() + lenght_of_word = len(word) + total_score = 0 + for letter in word_upper: + if letter in score_values: + total_score += score_values[letter] + if lenght_of_word > 6: + total_score += 8 + + return total_score # def get_highest_word_score(word_list): # pass \ No newline at end of file From 5d03c478c30834e36814f9c766733cd1ca2376cf Mon Sep 17 00:00:00 2001 From: Laura Date: Sat, 18 Mar 2023 07:38:32 -0700 Subject: [PATCH 06/10] write get_highest_word_score --- adagrams/game.py | 25 +++++++++++++++++++++++-- 1 file changed, 23 insertions(+), 2 deletions(-) diff --git a/adagrams/game.py b/adagrams/game.py index 54a610ca..3a0c8d89 100644 --- a/adagrams/game.py +++ b/adagrams/game.py @@ -119,5 +119,26 @@ def score_word(word): return total_score -# def get_highest_word_score(word_list): -# pass \ No newline at end of file +def get_highest_word_score(word_list): + list_of_scores = [] + for element in word_list: + score = score_word(element) + my_tuple = element, score + list_of_scores.append(my_tuple) + + sorted_by_second = sorted(list_of_scores, key=lambda tup: tup[1], reverse=True) + if sorted_by_second[0][1] > sorted_by_second[1][1]: + return sorted_by_second[0] + else: + min_len = sorted_by_second[0][1] + list_of_shortest = [] + for tup in sorted_by_second: + if len(tup[0]) == 10: + return tup + elif len(tup[0]) < min_len: + min_len = len(tup[0]) + list_of_shortest.append(tup) + return list_of_shortest[-1] + + + From 9a661e2abaa3273e0c18c6cf3341400ab81c97c0 Mon Sep 17 00:00:00 2001 From: Laura Date: Wed, 22 Mar 2023 06:43:56 -0700 Subject: [PATCH 07/10] Erase some comments --- adagrams/game.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/adagrams/game.py b/adagrams/game.py index 3a0c8d89..2cebf22f 100644 --- a/adagrams/game.py +++ b/adagrams/game.py @@ -49,7 +49,7 @@ def draw_letters(): def uses_available_letters(word, letter_bank): - + # Check if input is valid and correct: # correct input new = word.upper() # check for new letters in bank and check doesnt copy letter bank From 104ba43f2dde37b271e845f0bf6cb0da8b34de4a Mon Sep 17 00:00:00 2001 From: Laura Date: Fri, 24 Mar 2023 15:05:09 -0700 Subject: [PATCH 08/10] refactoring first wave and pass tests --- adagrams/game.py | 53 +++++++++++++++++++++++++++++++++++------------- 1 file changed, 39 insertions(+), 14 deletions(-) diff --git a/adagrams/game.py b/adagrams/game.py index 2cebf22f..0626b3c8 100644 --- a/adagrams/game.py +++ b/adagrams/game.py @@ -1,4 +1,5 @@ import random +LETTER_HAND = 10 LETTER_POOL = { 'A': 9, 'B': 2, @@ -27,25 +28,49 @@ 'Y': 2, 'Z': 1 } + +def check_for_values(dict,list, letter): + count_letter = list.count(letter) + print(f"count letter: {count_letter}, letter {letter}") + print(dict[letter]) + if dict[letter] >= count_letter: + return True + else: + return False + def draw_letters(): - # create a new pool of letters (every letter is there as many times as the value of the dic indicates) - letters = [] - for k, v in LETTER_POOL.items(): - letter_times = k * v - letters.append(letter_times) - big_string = ''.join(letters) + hand_list = [] + while len(hand_list) < LETTER_HAND: + a_letter = random.choice(list(LETTER_POOL.keys())) + hand_list.append(a_letter) + value_enough_times = check_for_values(LETTER_POOL, hand_list, a_letter) + if value_enough_times is True: + continue + else: + hand_list.pop() + + return hand_list + +# old version: not brave enough to erase it. + # # create a new pool of letters (every letter is there as many times as the value of the dic indicates) + # letters = [] + # for k, v in LETTER_POOL.items(): + # letter_times = k * v + # letters.append(letter_times) + # big_string = ''.join(letters) - # select letters (random) - selected_letters = [] + # # select letters (random) + # selected_letters = [] - for i in range(0,10): - letter_for_list = random.choice(big_string) - selected_letters.append(letter_for_list) - index = big_string.index(letter_for_list) - big_string = big_string[:index]+ big_string[index+1:] + # for i in range(0,10): + # letter_for_list = random.choice(big_string) + # selected_letters.append(letter_for_list) + # index = big_string.index(letter_for_list) + # big_string = big_string[:index]+ big_string[index+1:] - return selected_letters + # return selected_letters + def uses_available_letters(word, letter_bank): From e2751ef4f0c4e0d7080629338507056337dd9935 Mon Sep 17 00:00:00 2001 From: Laura Date: Sat, 25 Mar 2023 13:38:21 -0700 Subject: [PATCH 09/10] Functions for wave 2 and 4. Test for modifications --- adagrams/game.py | 131 +++++++++++++++++++++++++++--------------- tests/test_wave_01.py | 2 +- tests/test_wave_02.py | 12 ++-- tests/test_wave_03.py | 1 + tests/test_wave_04.py | 50 +++++++++++++++- 5 files changed, 142 insertions(+), 54 deletions(-) diff --git a/adagrams/game.py b/adagrams/game.py index 0626b3c8..eab464ba 100644 --- a/adagrams/game.py +++ b/adagrams/game.py @@ -29,6 +29,8 @@ 'Z': 1 } +# wave 1: + def check_for_values(dict,list, letter): count_letter = list.count(letter) print(f"count letter: {count_letter}, letter {letter}") @@ -52,7 +54,7 @@ def draw_letters(): return hand_list -# old version: not brave enough to erase it. +# wave 1 old version: not brave enough to erase it. # # create a new pool of letters (every letter is there as many times as the value of the dic indicates) # letters = [] # for k, v in LETTER_POOL.items(): @@ -72,36 +74,46 @@ def draw_letters(): # return selected_letters - +# Wave 2: def uses_available_letters(word, letter_bank): - # Check if input is valid and correct: - # correct input - new = word.upper() - # check for new letters in bank and check doesnt copy letter bank - for letter in new: + + upper_word = word.upper() + for letter in upper_word: if letter not in letter_bank: return False - count_letters_in_bank = {} - for letter in letter_bank: - if letter not in count_letters_in_bank: - count_letters_in_bank[letter] = 1 - else: - count_letters_in_bank[letter] += 1 - count_letters_in_new = {} - for letter in new: - if letter not in count_letters_in_new: - count_letters_in_new[letter] = 1 + elif upper_word.count(letter) > letter_bank.count(letter): + return False else: - count_letters_in_new[letter] += 1 - - for k, v in count_letters_in_new.items(): - for key, value in count_letters_in_bank.items(): - if k == key: - if v <= value: - print(f"value {value}") - return True - else: - return False + continue + return True + + # # Wave3 old version -not brave enough to erase-: + # new = word.upper() + # # check for new letters in bank and check doesnt copy letter bank + # for letter in new: + # if letter not in letter_bank: + # return False + # count_letters_in_bank = {} + # for letter in letter_bank: + # if letter not in count_letters_in_bank: + # count_letters_in_bank[letter] = 1 + # else: + # count_letters_in_bank[letter] += 1 + # count_letters_in_new = {} + # for letter in new: + # if letter not in count_letters_in_new: + # count_letters_in_new[letter] = 1 + # else: + # count_letters_in_new[letter] += 1 + + # for k, v in count_letters_in_new.items(): + # for key, value in count_letters_in_bank.items(): + # if k == key: + # if v <= value: + # print(f"value {value}") + # return True + # else: + # return False def score_word(word): @@ -144,26 +156,53 @@ def score_word(word): return total_score +# Wave 4 old version: +# def get_highest_word_score2(word_list): +# list_of_scores = [] +# for element in word_list: +# score = score_word(element) +# my_tuple = element, score +# list_of_scores.append(my_tuple) + +# sorted_by_second = sorted(list_of_scores, key=lambda tup: tup[1], reverse=True) +# if sorted_by_second[0][1] > sorted_by_second[1][1]: +# return sorted_by_second[0] +# else: +# min_len = sorted_by_second[0][1] +# list_of_shortest = [] +# for tup in sorted_by_second: +# if len(tup[0]) == 10: +# return tup +# elif len(tup[0]) < min_len: +# min_len = len(tup[0]) +# list_of_shortest.append(tup) +# return list_of_shortest[-1] + + +# Wave 4: +def higher_than(tuple1, tuple2): + '''returns True if word1 ranks higher than word2''' + score_word1 = tuple1[1] + score_word2 = tuple2[1] + if score_word1 == score_word2: + lenght_word1 = len(tuple1[0]) + lenght_word2 = len(tuple2[0]) + if lenght_word1 == 10 and lenght_word2 != 10: + return True + if lenght_word2 == 10 and lenght_word1 != 10: + return False + return lenght_word1 < lenght_word2 + return score_word1 > score_word2 + + def get_highest_word_score(word_list): - list_of_scores = [] - for element in word_list: - score = score_word(element) - my_tuple = element, score - list_of_scores.append(my_tuple) - - sorted_by_second = sorted(list_of_scores, key=lambda tup: tup[1], reverse=True) - if sorted_by_second[0][1] > sorted_by_second[1][1]: - return sorted_by_second[0] - else: - min_len = sorted_by_second[0][1] - list_of_shortest = [] - for tup in sorted_by_second: - if len(tup[0]) == 10: - return tup - elif len(tup[0]) < min_len: - min_len = len(tup[0]) - list_of_shortest.append(tup) - return list_of_shortest[-1] + best_tuple = None + for word in word_list: + current_tuple = word, score_word(word) + if best_tuple is None or higher_than(current_tuple,best_tuple): + best_tuple = current_tuple + return best_tuple + diff --git a/tests/test_wave_01.py b/tests/test_wave_01.py index ef48e03b..3d05f678 100644 --- a/tests/test_wave_01.py +++ b/tests/test_wave_01.py @@ -64,7 +64,7 @@ def test_letter_not_selected_too_many_times(): # Assert for letter in letters: - assert letter_freq[letter] <= LETTER_POOL[letter] + assert letter_freq[letter] <= LETTER_POOL[letter], ("letter: {}".format(letter)) def test_draw_letters_returns_different_hands(): # Arrange/Act diff --git a/tests/test_wave_02.py b/tests/test_wave_02.py index 5ee8910b..a643f285 100644 --- a/tests/test_wave_02.py +++ b/tests/test_wave_02.py @@ -2,7 +2,7 @@ from adagrams.game import uses_available_letters -# pasó reconocer que está en el letter bank + def test_uses_available_letters_true_word_in_letter_bank(): # Arrange letters = ["D", "O", "G", "X", "X", "X", "X", "X", "X", "X"] @@ -26,7 +26,6 @@ def test_uses_available_letters_false_word_in_letter_bank(): # Assert assert is_valid == False -# pasó contar la cantidad de veces que se usa cada letra def test_uses_available_letters_false_word_overuses_letter(): # Arrange @@ -39,7 +38,7 @@ def test_uses_available_letters_false_word_overuses_letter(): # Assert assert is_valid == False -@pytest.mark.skip(reason="no way of currently testing this") + def test_uses_available_letters_does_not_change_letter_bank(): # Arrange letters = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"] @@ -51,9 +50,9 @@ def test_uses_available_letters_does_not_change_letter_bank(): # Assert assert is_valid == True - assert letters == letters_copy + assert letters == letters_copy, "pass this difficult test" + -# paso mayusculas: def test_uses_available_letters_ignores_case(): # Arrange letters = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"] @@ -62,4 +61,5 @@ def test_uses_available_letters_ignores_case(): assert uses_available_letters("bEd", letters), "Test1" assert uses_available_letters("fad", letters),"Test2" assert uses_available_letters("a", letters), "Test3" - assert not uses_available_letters("aA", letters), "Test4" \ No newline at end of file + assert not uses_available_letters("aA", letters), "Test4" + diff --git a/tests/test_wave_03.py b/tests/test_wave_03.py index 5473db39..174911e6 100644 --- a/tests/test_wave_03.py +++ b/tests/test_wave_03.py @@ -18,6 +18,7 @@ def test_score_zero_for_empty(): # Assert assert score_word("") == 0 + def test_score_extra_points_for_seven_or_longer(): # Assert assert score_word("XXXXXXX") == 64 diff --git a/tests/test_wave_04.py b/tests/test_wave_04.py index e586621c..27fb099b 100644 --- a/tests/test_wave_04.py +++ b/tests/test_wave_04.py @@ -1,6 +1,54 @@ import pytest -from adagrams.game import score_word, get_highest_word_score +from adagrams.game import score_word, get_highest_word_score, higher_than + +def test_rank_higher_than_returns_False_when_both_tuples_tie_and_have_10_letters(): + tuple1 = ("AAAAAAAAAA",18) + tuple2 = ("BBBBBBBBBB",18) + + result = higher_than(tuple1,tuple2) + + assert result is False + +def test_rank_higher_than_returns_True_when_tuple1_has_10_letters(): + tuple1 = ("AAAAAAAAAA",18) + tuple2 = ("QJ",18) + + result = higher_than(tuple1,tuple2) + + assert result is True + +def test_rank_higher_than_returns_True_when_scores_are_equal_but_tuple1_is_shorter(): + tuple1 = ("QZ", 12) + tuple2 = ("VVVVV",12) + + result = higher_than(tuple1,tuple2) + + assert result is True + +def test_rank_higher_than_returns_False_when_scores_are_equal_but_tuple1_is_longer(): + tuple2 = ("QZ",5) + tuple1 = ("VVVVV",5) + + result = higher_than(tuple1,tuple2) + + assert result is False + +def test_rank_higher_than_returns_True_when_tuple1_has_higher_score(): + tuple1 = ("QZ",20) + tuple2 = ("AAA",10) + + result = higher_than(tuple1, tuple2) + + assert result is True + +def test_rank_higher_than_returns_False_when_tuple1_has_lower_score(): + tuple1 = ("AAA",3) + tuple2 = ("QZ",10) + + result = higher_than(tuple1, tuple2) + + assert result is False def test_get_highest_word_score_accurate(): # Arrange From e511171710286ee45240ecae298140b31e44b258 Mon Sep 17 00:00:00 2001 From: Laura Date: Fri, 31 Mar 2023 18:08:58 -0700 Subject: [PATCH 10/10] Refactored version --- adagrams/game.py | 128 +++++++++----------------------------- tempCodeRunnerFile.python | 5 ++ 2 files changed, 36 insertions(+), 97 deletions(-) create mode 100644 tempCodeRunnerFile.python diff --git a/adagrams/game.py b/adagrams/game.py index eab464ba..c4c3d442 100644 --- a/adagrams/game.py +++ b/adagrams/game.py @@ -28,6 +28,34 @@ 'Y': 2, 'Z': 1 } +SCORE_VALUES = { + 'A': 1, + 'B': 3, + 'C': 3, + 'D': 2, + 'E': 1, + 'F': 4, + 'G': 2, + 'H': 4, + 'I': 1, + 'J': 8, + 'K': 5, + 'L': 1, + 'M': 3, + 'N': 1, + 'O': 1, + 'P': 3, + 'Q': 10, + 'R': 1, + 'S': 1, + 'T': 1, + 'U': 1, + 'V': 4, + 'W': 4, + 'X': 8, + 'Y': 4, + 'Z': 10 +} # wave 1: @@ -54,25 +82,6 @@ def draw_letters(): return hand_list -# wave 1 old version: not brave enough to erase it. - # # create a new pool of letters (every letter is there as many times as the value of the dic indicates) - # letters = [] - # for k, v in LETTER_POOL.items(): - # letter_times = k * v - # letters.append(letter_times) - # big_string = ''.join(letters) - - # # select letters (random) - # selected_letters = [] - - # for i in range(0,10): - # letter_for_list = random.choice(big_string) - # selected_letters.append(letter_for_list) - # index = big_string.index(letter_for_list) - # big_string = big_string[:index]+ big_string[index+1:] - - # return selected_letters - # Wave 2: def uses_available_letters(word, letter_bank): @@ -87,97 +96,22 @@ def uses_available_letters(word, letter_bank): continue return True - # # Wave3 old version -not brave enough to erase-: - # new = word.upper() - # # check for new letters in bank and check doesnt copy letter bank - # for letter in new: - # if letter not in letter_bank: - # return False - # count_letters_in_bank = {} - # for letter in letter_bank: - # if letter not in count_letters_in_bank: - # count_letters_in_bank[letter] = 1 - # else: - # count_letters_in_bank[letter] += 1 - # count_letters_in_new = {} - # for letter in new: - # if letter not in count_letters_in_new: - # count_letters_in_new[letter] = 1 - # else: - # count_letters_in_new[letter] += 1 - - # for k, v in count_letters_in_new.items(): - # for key, value in count_letters_in_bank.items(): - # if k == key: - # if v <= value: - # print(f"value {value}") - # return True - # else: - # return False def score_word(word): - score_values = { - 'A': 1, - 'B': 3, - 'C': 3, - 'D': 2, - 'E': 1, - 'F': 4, - 'G': 2, - 'H': 4, - 'I': 1, - 'J': 8, - 'K': 5, - 'L': 1, - 'M': 3, - 'N': 1, - 'O': 1, - 'P': 3, - 'Q': 10, - 'R': 1, - 'S': 1, - 'T': 1, - 'U': 1, - 'V': 4, - 'W': 4, - 'X': 8, - 'Y': 4, - 'Z': 10 -} + word_upper = word.upper() lenght_of_word = len(word) total_score = 0 for letter in word_upper: - if letter in score_values: - total_score += score_values[letter] + if letter in SCORE_VALUES: + total_score += SCORE_VALUES[letter] if lenght_of_word > 6: total_score += 8 return total_score -# Wave 4 old version: -# def get_highest_word_score2(word_list): -# list_of_scores = [] -# for element in word_list: -# score = score_word(element) -# my_tuple = element, score -# list_of_scores.append(my_tuple) -# sorted_by_second = sorted(list_of_scores, key=lambda tup: tup[1], reverse=True) -# if sorted_by_second[0][1] > sorted_by_second[1][1]: -# return sorted_by_second[0] -# else: -# min_len = sorted_by_second[0][1] -# list_of_shortest = [] -# for tup in sorted_by_second: -# if len(tup[0]) == 10: -# return tup -# elif len(tup[0]) < min_len: -# min_len = len(tup[0]) -# list_of_shortest.append(tup) -# return list_of_shortest[-1] - # Wave 4: def higher_than(tuple1, tuple2): diff --git a/tempCodeRunnerFile.python b/tempCodeRunnerFile.python new file mode 100644 index 00000000..551af7a1 --- /dev/null +++ b/tempCodeRunnerFile.python @@ -0,0 +1,5 @@ +list = [("XXX",1),("XCV",4),("DDD",7)("DER", 9),("ERT",3)] +list_b = ["XXX", "XXXX", "XX", "X"] + +for i in range(len(list)): + print(list[i][0]) \ No newline at end of file