W3C中级算法挑战之python实现

 最近在学python，网上很难找到对应的算法题网站，专业算法网站大部分都是国外的，之前在w3cschool看到有三个级别的Javascript脚本算法挑战，尝试用python实现，代码量相对比较少，如果你有更好的解法，还请不吝赐教，初学python，希望和大家一起日有所长。

目录

1.区间求值算法挑战

2.找出数组间差异算法挑战

3.数字转罗马数字

4.对象搜索算法挑战

5.字符串查询替换算法挑战

6.字符串移动插入算法挑战

7.字符配对算法挑战

8.字符串查询补充算法挑战

9.输入检查算法挑战

10.数组去重算法挑战

11.html符号转实体算法挑战

12.字符串连接算法挑战

13.斐波纳契奇数求和算法挑战

14.质素求和算法挑战

15.最小公倍数算法挑战

16.数组验证算法挑战

17.数组取值算法挑战

18.数组平铺算法挑战

19.二进制转字符算法挑战

20.数组元素判断算法挑战

21.函数迭代可选参数算法挑战

---

1.区间求值算法挑战

---

我们会传递给你一个包含两个数字的数组。返回这两个数字和它们之间所有数字的和。

最小的数字并非总在最前面。

def sumAll(lst):
    sum = 0
    for i in range(min(lst), max(lst) + 1):
        sum += i
    return sum


print(sumAll([10, 5]))

2.找出数组间差异算法挑战

---

比较两个数组，然后返回一个新数组，该数组的元素为两个给定数组中所有独有的数组元素。换言之，返回两个数组的差异。

如果你被难住了，记得使用 Read-Search-Ask尝试与他人交流编程思路、编写你自己的代码。

def diff(lst1, lst2):
	lst = []
	for i in lst1:
		if i not in lst2:
			lst.append(i)
	for i in lst2:
		if i not in lst1:
			lst.append(i)
	return list(set(lst))


print(diff([1, 2, 3, 5, 6, 6 ], [1, 2, 3, 4, 5]))

3.数字转罗马数字

---

将给定的数字转换成罗马数字。

所有返回的 罗马数字 都应该是大写形式。

如果你被难住了，记得使用 Read-Search-Ask尝试与他人交流编程思路、但编写你自己的代码。

def convert(n):
    dct = {0: "", 1: "I", 2: "II", 3: "III", 4: "IV", 5: "V",
           6: "VI", 7: "VII", 8: "VIII", 9: "IX", 10: "X",
           20: "XX", 30: "XXX", 40: "XL", 50: "L",
           60: "LX", 70: "LXX", 80: "LXXX", 90: "XC", 100: "C",
           200: "CC", 300: "CCC", 400: "CD", 500: "D",
           600: "DC", 700: "DCC", 800: "DCCC", 900: "CM", 1000: "M",
           2000: "MM", 3000: "MMM"}
    s = str(n)
    result = ""
    for i, j in enumerate(s):
        key1 = int(j) * (10 ** (len(s) - i - 1))
        result += dct[key1]
    return result


print(convert(3999))  # 返回 "MMMCMXCIX"，该算法只能返回1-3999的数字

4.对象搜索算法挑战

---

写一个 function方法，它遍历一个对象数组（第一个参数）并返回一个包含相匹配的属性-值对（第二个参数）的所有对象的数组。如果返回的数组中包含 source 对象的属性-值对，那么此对象的每一个属性-值对都必须存在于 collection 的对象中。

例如，如果第一个参数是 [{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }]，第二个参数是 { last: "Capulet" }，那么你必须从数组（第一个参数）返回其中的第三个对象，因为它包含了作为第二个参数传递的属性-值对。

def where(lst, dct):
    for l in lst:
        i = 0
        for d in dct.keys():
            if d in l and dct[d] == l[d]:
                i += 1
                if i == len(dct):
                    return l
            else:
                break


print(where([{"a": 1, "b": 2}, {"a": 1}, {"a": 1, "b": 2, "c": 2}], {"a": 1, "c": 2}))

5.字符串查询替换算法挑战

---

使用给定的参数对字符串执行一次查找和替换，然后返回新字符串。

第一个参数是将要对其执行查找和替换的字符串。

第二个参数是将被替换掉的单词（替换前的单词）。

第三个参数用于替换第二个参数（替换后的单词）。

注意：替换时保持原单词的大小写。例如，如果你想用单词 "dog" 替换单词 "Book" ，你应该替换成 "Dog"。

def myReplace(str, old_str, new_str):
    if str[0].isupper():
        newstr = str.replace(old_str, new_str.capitalize())
    else:
        newstr = str.replace(old_str, new_str)
    return newstr


print(myReplace("Let us get back to more Coding", "Coding", "algorithms"))

6.字符串移动插入算法挑战

---

把指定的字符串翻译成 pig latin。

Pig Latin 把一个英文单词的第一个辅音或辅音丛（consonant cluster）移到词尾，然后加上后缀 "ay"。

如果单词以元音开始，你只需要在词尾添加 "way" 就可以了。

输入字符串保证是英文单词全部小写。

translate("eight") 应该返回 "eightway"。

def translate(s):
    if s[0] in ["a","e","i","o","u"]:
        return s+"way"
    else:
        return s[1:]+s[0]+"ay"


print(translate("eight"))
print(translate("california"))

 

7.字符配对算法挑战

---

DNA 链缺少配对的碱基。依据每一个碱基，为其找到配对的碱基，然后将结果作为第二个数组返回。

Base pairs（碱基对） 是一对 AT 和 CG，为给定的字母匹配缺失的碱基。

在每一个数组中将给定的字母作为第一个碱基返回。

例如，对于输入的 GCG，相应地返回 [["G", "C"], ["C","G"],["G", "C"]]

字母和与之配对的字母在一个数组内，然后所有数组再被组织起来封装进一个数组。

用字典：

def pair(str):
    dct = {"A": "T", "T": "A", "C": "G", "G": "C"}
    lst = [[i, dct[i]] for i in str]
    return lst


print(pair("CTCTA"))

 三元运算符一行代码搞定，可读性比较低：

def pair(str):
    lst = [[i, "C" if i == "G" else "G" if i == "C" else "A" if i == "T" else "T" if i == "A" else ""] for i in str]
    return lst


print(pair("CTCTA"))

8.字符串查询补充算法挑战

---

从传递进来的字母序列中找到缺失的字母并返回它。

如果所有字母都在序列中，返回 undefined。

fearNotLetter("abcdefghjklmno") 应该返回 "i"。

fearNotLetter("bcd") 应该返回 undefined。

def fearNotLetter(str):
    lst = []
    s = str[0]
    for i in str[1:]:
        if i != chr(ord(s) + 1):
            lst.append(chr(ord(s) + 1))
        s = i
    if not lst:
        return "undefined"
    else:
        return lst


print(fearNotLetter("abcefghjklmno"))
print(fearNotLetter("abcdefghijklmno"))

9.输入检查算法挑战

---

检查一个值是否是基本布尔类型，并返回 true 或 false。

基本布尔类型即 true 和 false。

boo(True) 应该返回 true。boo(False) 应该返回 true。其他均返回false

def boo(data):
    if type(data)==bool:
        return data
    else:
        return False


print(boo(1))
print(boo("1"))
print(boo(True))

10.数组去重算法挑战

---

写一个 function，传入两个或两个以上的数组，返回一个以给定的原始数组排序的不包含重复值的新数组。

换句话说，所有数组中的所有值都应该以原始顺序被包含在内，但是在最终的数组中不包含重复值。

非重复的数字应该以它们原始的顺序排序，但最终的数组不应该以数字顺序排序。

unite([1, 2, 3], [5, 2, 1]) 应该返回 [1, 2, 3, 5]。

unite([1, 2, 3], [5, 2, 1, 4], [2, 1], [6, 7, 8]) 应该返回 [1, 2, 3, 5, 4, 6, 7, 8]。

def unite(*args):
    lst=[]
    for arg in args:
        for i in arg:
            if i not in lst:
                lst.append(i)
    return lst


print(unite([1, 2, 3], [5, 2, 1, 4], [2, 1], [6, 7, 8]))

11.html符号转实体算法挑战

---

将字符串中的字符 &、<、>、" （双引号）, 以及 ' （单引号）转换为它们对应的 HTML 实体。

convert("Dolce & Gabbana") 应该返回 Dolce &​amp; Gabbana。

convert("Hamburgers < Pizza < Tacos") 应该返回 Hamburgers &​lt; Pizza &​lt; Tacos。

convert("Sixty > twelve") 应该返回 Sixty &​gt; twelve。

convert('Stuff in "quotation marks"') 应该返回 Stuff in &​quot;quotation marks&​quot;。

convert("Shindler's List") 应该返回 Shindler&​apos;s List。

convert("<>") 应该返回 &​lt;&​gt;。

convert("abc") 应该返回 abc。

def convert(str):
    str = str.replace("&", "&")
    str = str.replace("<", "&lt;")
    str = str.replace(">", "&gt;")
    str = str.replace('"', "&quot;")
    str = str.replace("'", "&apos;")
    return str


print(convert("Dolce & Gabbana"))
print(convert("Hamburgers < Pizza < Tacos"))
print(convert('Stuff in "quotation marks"'))
print(convert("Shindler's List"))
print(convert("<>"))
print(convert("abc"))

 字典与map配合执行替换，速度稍慢：

def convert(str1):
    dct = {"&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&apos;"}
    str1 = "".join(list(map(lambda a: dct[a] if dct.get(a) else a, list(str1))))
    return str1

 

12.字符串连接算法挑战

---

将字符串转换为 spinal case。Spinal case 是 all-lowercase-words-joined-by-dashes 这种形式的，也就是以连字符连接所有小写单词。

spinalCase("This Is Spinal Tap") 应该返回 "this-is-spinal-tap"。

spinalCase("thisIsSpinalTap") 应该返回 "this-is-spinal-tap"。

spinalCase("The_Andy_Griffith_Show") 应该返回 "the-andy-griffith-show"。

spinalCase("Teletubbies say Eh-oh") 应该返回 "teletubbies-say-eh-oh"。

def spinalCase(s):
	if " " in s or "_" in s:
		s.replace(" ", "-")
		s.replace("_", "-")
		return s.lower()
	else:
		return "".join([("-" + i.lower()) if i.isupper() else i for i in s])


print(spinalCase("Teletubbies say Eh-oh"))
print(spinalCase("thisIsSpinalTap"))
print(spinalCase("The_Andy_Griffith_Show"))
print(spinalCase("This Is Spinal Tap"))

13.斐波纳契奇数求和算法挑战

---

给一个正整数num，返回小于或等于num的斐波纳契奇数之和。

斐波纳契序列中的前两个数字是1和1.序列中的每个附加数字是前面两个数字的和。斐波纳契序列的前六个数字是1,1,2,3,5和8。

例如，sumFibs(4)应该返回 5，因为斐波纳契数列中所有小于4的奇数是 1、1、3。

提示：此题不能用递归来实现斐波纳契数列。因为当num较大时，内存会溢出，推荐用数组来实现。

sumFibs(1) 应该返回一个数字。

sumFibs(1000) 应该返回 1785。

sumFibs(4000000) 应该返回 4613732。

sumFibs(4) 应该返回 5。

sumFibs(75024) 应该返回 60696。

sumFibs(75025) 应该返回 135721。

def sumFibs(n):
    lst = [1, 1]
    result = 2
    for i in range(2, n):
        lst.append(lst[-2] + lst[-1])
        if lst[-1] > n:
            break
        if lst[i] % 2 == 1:
            result += lst[i]
    return result


print(sumFibs(75024))
print(sumFibs(75025))

14.质素求和算法挑战

---

求小于等于给定数值的质数之和。

只有 1 和它本身两个约数的数叫质数。例如，2 是质数，因为它只能被 1 和 2 整除。1 不是质数，因为它只能被自身整除。

给定的数不一定是质数。

sumPrimes(10) 应该返回一个数字。

sumPrimes(10) 应该返回 17。

sumPrimes(977) 应该返回 73156。

def sumPrimes(n):
    result = 0
    for i in range(2, n + 1):
        flag = 0
        for j in range(2, i):
            if i % j == 0:
                flag = 1
                break
        if flag == 0:
            result += i
    return result


print(sumPrimes(977))

15.最小公倍数算法挑战

---

找到所提供参数的最小公倍数，这两个参数可以均匀分配，以及这些参数之间范围内的所有最小公倍数。

范围是两个数字构成的数组，两个数字不一定按数字顺序排序。

例如对 1 和 3 —— 找出能被 1 和 3 和它们之间所有数字整除的最小公倍数。

smallestCommons([1, 5]) 应该返回一个数字。

smallestCommons([1, 5]) 应该返回 60。

smallestCommons([5, 1]) 应该返回 60。

smallestCommons([1, 13]) 应该返回 360360。

def smallestCommons(lst):
    m = max(lst)
    n = min(lst)
    sum1 = 1
    for i in range(n, m + 1):
        sum1 *= i
    for j in range(m, sum1 + 1, m):  # 从最大值m到乘积之和sum1，遍历步长m，找最大公倍数
        flag = 0
        for a in range(2, m + 1):  # 当j能被所有数整除时，返回j
            if j % a == 0:
                flag += 1
                if flag == m - 1:
                    return j
            else:
                break


print(smallestCommons([13, 1]))

16.数组验证算法挑战

---

写一个 function，它查找数组（第一个参数）并返回数组中第一个通过某种方法（第二个参数）验证的元素。

find([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; }) 应该返回 8。

find([1, 3, 5, 9], function(num) { return num % 2 === 0; })应该返回 undefined。

def find(lst, fun):
    lst_flt = list(filter(fun, lst))
    if lst_flt:
        return lst_flt[0]
    else:
        return "undefined"


print(find([1, 3, 5, 9], lambda a: a % 2 == 0))
print(find([1, 3, 5, 8, 9, 10], lambda a: a % 2 == 0))

17.数组取值算法挑战

---

删除数组(第一个参数)的元素，从左边开始，直到回调函数（第二个参数）return true就停止。

第二个参数，func，是一个函数。用来测试数组的第一个元素，如果返回fasle，就从数组中抛出该元素(注意：此时数组已被改变)，继续测试数组的第一个元素，如果返回fasle，继续抛出，直到返回true。

最后返回数组的剩余部分，如果没有剩余，就返回一个空数组。

drop([1, 2, 3, 4], function(n) {return n >= 3;}) 应该返回 [3, 4]。

drop([0, 1, 0, 1], function(n) {return n === 1;}) 应该返回 [1, 0, 1]。

drop([1, 2, 3], function(n) {return n > 0;}) 应该返回 [1, 2, 3]。

drop([1, 2, 3, 4], function(n) {return n > 5;}) 应该返回 []。

drop([1, 2, 3, 7, 4], function(n) {return n > 3;}) 应该返回 [7, 4]。

drop([1, 2, 3, 9, 2], function(n) {return n > 2;}) 应该返回 [3, 9, 2]。

def drop(lst, fun):
    lst_mapped = list(map(fun, lst))
    if True in lst_mapped:
        return lst[:lst_mapped.index(True)]
    else:
        return lst


print(drop([1, 2, 3, 4], lambda a: a > 5))
print(drop([1, 2, 3, 9, 2], lambda a: a > 2))

18.数组平铺算法挑战

---

对嵌套的数组进行平铺嵌套数组。你必须考虑到不同层级的嵌套。

steamroller([[["a"]], [["b"]]]) 应该返回 ["a", "b"]。

steamroller([1, [2], [3, [[4]]]]) 应该返回 [1, 2, 3, 4]。

steamroller([1, [], [3, [[4]]]]) 应该返回 [1, 3, 4]。

steamroller([1, {}, [3, [[4]]]]) 应该返回 [1, {}, 3, 4]。

递归实现，代码是写出来了，对递归还不是很熟练，不知道有没有bug：

def steamroller(lst):
    lst1 = []

    def fun(lst2):
        for i in lst2:
            if type(i) != list:
                lst1.append(i)
            else:
                fun(i)

    fun(lst)
    return lst1


print(steamroller([[["a"]], [["b"]]]))
print(steamroller([1, [2], [3, [[4]]]]))
print(steamroller([1, [], [3, [[4]]]]))
print(steamroller([1, {}, [3, [[4]]]]))

19.二进制转字符算法挑战

---

传入二进制字符串，翻译成英语句子并返回。

二进制字符串是以空格分隔的。

binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111") 应该返回 "Aren't bonfires fun!?"

binaryAgent("01001001 00100000 01101100 01101111 01110110 01100101 00100000 01000110 01110010 01100101 01100101 01000011 01101111 01100100 01100101 01000011 01100001 01101101 01110000 00100001") 应该返回 "I love FreeCodeCamp!"

def binaryAgent(s):
    lst = s.split(" ")
    str1 = ""
    for i in lst:
        sum = 0
        for m, n in enumerate(i):
            sum += (2 ** (7 - m) * int(n))
        str1 += chr(sum)
    return str1


print(binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111"))
print(binaryAgent("01001001 00100000 01101100 01101111 01110110 01100101 00100000 01000110 01110010 01100101 01100101 01000011 01101111 01100100 01100101 01000011 01100001 01101101 01110000 00100001"))

20.数组元素判断算法挑战

---

所有的东西都是真的！

完善编辑器中的every函数，如果集合(collection)中的所有对象都存在对应的属性(第二个参数)，并且属性(第二个参数)对应的值为真。函数返回ture。反之，返回false。

记住：您可以通过点符号或[]符号来访问对象属性。

every([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true, "alias": "Repete"}, {"name": "FastFoward", "onBoat": true}], "onBoat") 应该返回 true

every([{"single": "yes"}], "single") 应该返回 true

every([{"single": ""}, {"single": "double"}], "single") 应该返回 false

every([{"single": "double"}, {"single": undefined}], "single") 应该返回 false

every([{"single": "double"}, {"single": NaN}], "single") 应该返回 false

def every(lst, str):
    try:
        i = 0
        for dct in lst:
            if dct[str]:
                i += 1
        if i == len(lst):
            return True
        else:
            return False
    except KeyError:
        return False

print(every([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex"))
print(every([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex"))
print(every([{"user": "Tinky-Winky", "sex": "male", "age": 0}, {"user": "Dipsy", "sex": "male", "age": 3}, {"user": "Laa-Laa", "sex": "female", "age": 5}, {"user": "Po", "sex": "female", "age": 4}], "age"))
print(every([{"name": "Pete", "onBoat": True}, {"name": "Repeat", "onBoat": True}, {"name": "FastFoward", "onBoat": None}], "onBoat"))
print(every([{"name": "Pete", "onBoat": True}, {"name": "Repeat", "onBoat": True, "alias": "Repete"}, {"name": "FastFoward", "onBoat": True}], "onBoat"))
print(every([{"single": "yes"}], "single"))
print(every([{"single": ""}, {"single": "double"}], "single"))

21.函数迭代可选参数算法挑战

---

创建一个计算两个参数之和的 function。如果只有一个参数，则返回一个 function，该 function 请求一个参数然后返回求和的结果。

例如，add(2, 3) 应该返回 5，而 add(2) 应该返回一个 function。

调用这个有一个参数的返回的 function，返回求和的结果：

var sumTwoAnd = add(2);

sumTwoAnd(3) 返回 5。

如果两个参数都不是有效的数字，则返回 undefined。

add(2, 3) 应该返回 5。

add(2)(3) 应该返回 5。

add("http://bit.ly/IqT6zt") 应该返回 undefined。

add(2, "3") 应该返回 undefined。

add(2)([3]) 应该返回 undefined。

函数内部定义的函数，在外层尝试捕获TypeError还是会报错TypeError，立个flag，老师说涉及到闭包还没学。

def add(*args):
    try:
        if len(args) == 2:
            return args[0] + args[1]
        else:
            def fun(a):
                if type(a) != int:
                    return "undefined"
                return a + args[0]

            return fun
    except TypeError:
        return "undefined"


print(add(2)([3]))
print(add(2, "3"))
print(add(2)(3))
print(add(2, 3))