hellog888's questions

为什么它返回一个空列表？

def count_smileys(arr):
    stack = []
    for i in range(len(arr)):
        for j in range(i):
            if arr[i][j] == ":" or arr[i][j] == ";":
                stack.append(arr[i][j])
            elif arr[i][j] == "~" or arr[i][j] == "-":
                if stack == 0:
                    return False
                else:
                    stack.append(arr[i][j])
            elif arr[i][j] == "D" or arr[i][j] == ")":
                if stack == 0:
                    return False
                else:
                    stack.append(arr[i][j])
        return stack

print(count_smileys([':D',':~)',';~D',':)']))         #, 4
print(count_smileys([':)',':(',':D',':O',':;']))      #, 2
print(count_smileys([';]', ':[', ';*', ':$', ';-D'])) #, 1

def find_even_index(arr):
    len_arr = len(arr)
    for i in range(len_arr):
        if sum(arr[:i]) == sum(arr[i:]) and sum(arr[:i]) != None and sum(arr[i:]) != None:
            break
        return i

我不明白如何绕过循环中的检查，我们不会得到 slice 的结果sum(arr[i:]) == 0，以及如何在循环中制作这种情况下的 slice？

以下是任务的条件：

您将获得一个整数数组。您的工作是获取该数组并找到一个索引 N，其中 N 左侧的整数之和等于 N 右侧的整数之和。如果没有索引会导致这种情况发生，请返回 -一。

例如：

假设给定数组 {1,2,3,4,3,2,1}：您的函数将返回索引 3，因为在数组的第 3 个位置，索引左侧的总和 ({ 1,2,3}) 和索引右侧的和 ({3,2,1}) 都等于 6。

让我们看看另一个。给定数组 {1,100,50,-51,1,1}：您的函数将返回索引 1，因为在数组的第一个位置，索引左侧 ({1}) 和索引右侧的总和 ({50,-51,1,1}) 都等于 1。

最后一个：给定数组 {20,10,-80,10,10,15,35} 在索引 0 左侧是 {} 右侧是 {10,-80,10,10,15,35 } 添加时它们都等于 0。（本题空数组等于0）索引0是左右两边相等的地方。

注意：请记住，在大多数编程/脚本语言中，数组的索引从 0 开始。

输入：一个长度为 0 < arr < 1000 的整数数组。数组中的数字可以是正整数或负整数。

输出：最低的索引 N，其中 N 的左边等于 N 的右边。如果你没有找到符合这些规则的索引，那么你将返回 -1。

注意：如果给定一个包含多个答案的数组，请返回正确的最低索引。

for j in url_pages_2:
    buf = url.replace("?page=1", j)
    response1 = requests.get(buf)
    soup1 = BeautifulSoup(response1.text, "lxml")
    items1 = soup1.find_all('div', class_='col-lg-4 col-md-6 mb-4')
    for n, item in enumerate(items1, start=1):
        name1 = item.find("h4", class_="card-title").text.strip()
        price = item.find("h5").text
        print(f'{n} {name1}: {price}')

如何继续计数？检索到的数据的页面只有9个位置?page=1，我的订单在经过1页后每次都是从1到9的新编号?page=1，如何从条件页继续下一个请求的顺序?page=2，以便计数继续从9到18

from collections import Counter
def duplicate_encode(word):
    cnt = dict(Counter(word.lower()))
    str = ''
    for i in word:
        if i in cnt:
            if cnt[i] < 2:
                str += '('
            else:
                str += ')'
    return str

本练习的目标是将字符串转换为新字符串，其中如果该字符在原始字符串中仅出现一次，则新字符串中的每个字符为“(”，如果该字符在原始字符串中多次出现，则为“)”细绳。在确定字符是否重复时忽略大小写。

例子 "din" => "((("

"后退" => "()()()"

"成功" => ")())())"

"((@" => "))(("

如何将数据从第一个表转换为第二个？你需要通过 Pandas 来完成

for i in range(len(robot_db['id'])):    
    buffer = [x for x in robot_db['id'][i]]    
    for j in range(len(robot_db['robot'][i])):
        robot_db['final'] = robot_db['id'][i] + '*' + robot_db['Name'][i]
        + '*' + robot_db['latitude'][i] + '*' + robot_db['longitude'][i]
        + '*' + buffer[j] + '/n'

您的任务是将句子截断为不超过给定字符数的长度。

如果句子已经足够短，你不需要对它做任何事情。如果需要截断，应在缩略句的末尾添加省略号（“...”）来表示缺失的部分。

一个缩写的句子可以包含整个单词和空格。它不得包含任何截断的单词或尾随空格。在计算允许的字符数时考虑了省略号，因此它不计入给定长度。

输入数据：两个参数：

单行句子为字符串 截断句子的最大长度为 int 输出：带有省略号（如果需要）作为一行的截断句子。

例子：

cut_sentence("Hi my name is Alex", 4) == "Hi..."
cut_sentence("Hi my name is Alex", 8) == "Hi my..."
cut_sentence("Hi my name is Alex", 18) == "Hi my name is Alex"
cut_sentence("Hi my name is Alex", 20) == "Hi my name is Alex"

我的代码：

def cut_sentence(line: str, length: int) -> str:
    list_ = [str(x) for x in line.split()]
    len_word = 0
    res_word = ''
    lst2 = []
    if len(line) == 0 or length == 1:
        return '...'
    elif len(line) - (length + 3) > 0:
        for i in list_:
            if len(res_word) > length-2:
                break
            lst2.append(i)
            res_word = ' '.join(lst2)
            res_word += '...'
    else:
        return f'{line[:length]}'        
    return res_word

我哪里错了？

from collections import Counter
import re
def checkio(text: str) -> str:
    text1 = re.findall('[^\W]', text.lower())
    a = (''.join(text1))
    text2 = re.findall('[a-z]', a)
    a1 = (''.join(text2))
    return(Counter(a1).most_common(1)[0][0])

print(checkio("Hello World!"))          # == "l", "Hello test"
print(checkio("How do you do?"))        # == "o", "O is most wanted"
print(checkio("One"))                   # == "e", "All letter only once."
print(checkio("Oops!"))                 # == "o", "Don't forget about lower case."
print(checkio("AAaooo!!!!"))            # == "a", "Only letters."
print(checkio("abe"))                   # == "a", "The First."
print(checkio("a" * 9000 + "b" * 1000)) # == "a", "Long." 

如果“One”应该是“e”，而“abe”应该是“a”，如何解决这个问题？

这里问了同样的问题：https ://ru.stackoverflow.com/questions/1036053/Most-frequent-letter-in-text

我的任务：

您的任务是按降序对数组中连续对之间的差异求和。

示例 [2, 1, 10] --> 9 按降序排列：[10, 2, 1]

总和：(10 - 2) + (2 - 1) = 8 + 1 = 9

如果数组为空或数组只有一个元素，则结果应为：0

这是我的代码：

    a = sorted(arr)[::-1]
    b = [a[i:i+2] for i in range(len(a)-1)]
    c = []
    for i in range(len(b)):
        for j in range(len(b[i])):
            try:
                c.append(int(b[i][j]-b[i][j+1]))
            except IndexError:
                break
    return sum(c)

不断尝试拯救我，免得越界，还有其他方法吗？

def correct(s):
    mapping = str.maketrans({'0': 'O', '1': 'I', '5': 'S'})
    return s.translate(mapping)
   #return string.replace('1','I').replace('0','O').replace('5','S')

print(correct("51NGAP0RE")) #=="SINGAPORE"

import re
def sum_by_types(items):
    num_list = [x for x in items if f'{x}'.isdigit()]
    str_list = [x for x in items if not f'{x}'.isdigit()]
    return num_list, str_list

print(sum_by_types([])) #== ("", 0)
print(sum_by_types([1, 2, 3])) #== ("", 6)
print(sum_by_types(["1", 2, 3])) #== ("1", 5)
print(sum_by_types(["1", "2", 3])) #== ("12", 3)
print(sum_by_types(["1", "2", "3"])) #== ("123", 0)
print(sum_by_types(["size", 12, "in", 45, 0])) #== ("sizein", 57)

任务： - 返回 2 个值。第一个是给定列表中所有字符串的串联。第二个是给定列表中所有整数的总和。

我无法理解如何从列表中选择数字 isdigit() 试过了。还有其他方法吗？

def powers_of_two(n):
    i = 1
    a = []
    for x in range(n):
        a.append(i ** 2)
        i = i + 1
    return a    


print((powers_of_two(0))) #-> [1]))
print((powers_of_two(1))) #-> [1, 2])
print((powers_of_two(4))) #-> [1, 2, 4, 8, 16]) 

序列应采用以下形式（#-> 在代码的注释中）：[1, 2, 4, 8, 16]

需要排序，但是按照绝对值升序排序。例如，序列 (-20, -5, 10, 15) 将按如下方式排序 (-5, 10, 15, -20)。你的函数必须返回一个列表（list）或一个元组（tuple）。

什么我不尝试不断没有输出。

def checkio(values: list) -> list:
    n = [int(x) for x in values]
    return abs(n).sort()

    print(checkio([-20, -5, 10, 15])) #== [-5, 10, 15, -20]
    print(checkio([1, 2, 3, 0])) #== [0, 1, 2, 3]
    print(checkio([-1, -2, -3, 0])) #== [0, -1, -2, -3]

def count_positives_sum_negatives(arr):
    list1 = [] 
    list2 = []
    for i in arr:
        if i > 0:
            list1.append(i)
        else:
            list2.append(i)    
    list3 = list([len(list1), sum(list2)])
    if list3:
        return list3

验证器不计算解决方案，它认为[0, 0] 应该等于 []作为错误 ，反之亦然[] 应该等于 [0, 0]。如何解决这个问题呢？

给定一个整数数组。

返回一个数组，其中第一个元素是正数的计数，第二个元素是负数的总和。0 既不是正也不是负。如果输入为空数组或为空，则返回一个空数组。

示例：对于输入 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, -11, -12, -13, -14, -15]，您应该返回 [10, -65] .

def check(seq, elem):
    list1 = list(str(x) for x in seq)
    return False if not elem in list1 else True
    
print(check([66, 101], 66)) 
print(check([78, 117, 110, 99, 104, 117, 107, 115], 8))
print(check([101, 45, 75, 105, 99, 107], 107))
print(check([80, 117, 115, 104, 45, 85, 112, 115], 45))
print(check(['t', 'e', 's', 't'], 'e'))
print(check(["what", "a", "great", "kata"], "kat"))
print(check([66, "codewars", 11, "alex loves pushups"], "alex loves pushups"))
print(check(["come", "on", 110, "2500", 10, '!', 7, 15], "Come"))
print(check(["when's", "the", "next", "Katathon?", 9, 7], "Katathon?"))
print(check([8, 7, 5, "bored", "of", "writing", "tests", 115], 45))
print(check(["anyone", "want", "to", "hire", "me?"], "me?"))

一个简单的真/假任务，但我不明白如果数组与字符串和数字混合，如何在函数中查找值？

def isdigit1(a):
    n_list = list(a)
    count = 0
    for s in n_list:
        if s.isdigit() == True:
            count += 1
    if count >= 1:
        return True
    else:
        return False   

def isalpha1(a):
    n_list = list(a)
    count = 0
    for s in n_list:
        if s.isalpha() == True:
            count += 1
    if count > 0:
        return True
    else:
        return False

def islower1(a):
    n_list = list(a)
    count = 0
    for s in n_list:
        if s.islower() == True:
            count += 1
    if count >= 1:
        return True
    else:
        return False

def isupper1(a):
    n_list = list(a)
    count = 0
    for s in n_list:
        if s.isupper() == True:
            count += 1
    if count >= 1:
        return True
    else:
        return False


if __name__ == '__main__':
    s = input()
    print(s.isalnum())
    print(isalpha1(s))
    print(isdigit1(s))
    print(islower1(s))
    print(isupper1(s))

解决方案检查验证器发誓，用于更多资源密集型测试

a = int(input())
b = 1

for i in range(a):
    hex1 = str('{0:X}'.format(b))
    binar = str('{0:b}'.format(b))
    Octal = str('{0:o}'.format(b))
    print(" ".join((f'{b:>}', f'{Octal:>}', f'{hex1:>}', f'{binar:>}')))
    b += 1

如何对齐输出结果得到：

    1     1     1     1
    2     2     2    10
    3     3     3    11
    4     4     4   100
    5     5     5   101
    6     6     6   110
    7     7     7   111
    8    10     8  1000
    9    11     9  1001
   10    12     A  1010
   11    13     B  1011
   12    14     C  1100
   13    15     D  1101
   14    16     E  1110
   15    17     F  1111
   16    20    10 10000
   17    21    11 10001

      1       1       1       1
      2       2       2      10
      3       3       3      11
      4       4       4     100
      5       5       5     101
      6       6       6     110
      7       7       7     111
      8      10       8    1000
      9      11       9    1001
     10      12       A    1010
     11      13       B    1011
     12      14       C    1100
     13      15       D    1101
     14      16       E    1110
     15      17       F    1111
     16      20      10   10000
     17      21      11   10001
     18      22      12   10010
     19      23      13   10011
     20      24      14   10100
     21      25      15   10101
     22      26      16   10110
     23      27      17   10111
     24      30      18   11000
     25      31      19   11001
     26      32      1A   11010
     27      33      1B   11011
     28      34      1C   11100
     29      35      1D   11101
     30      36      1E   11110
     31      37      1F   11111
     32      40      20  100000
     33      41      21  100001
     34      42      22  100010
     35      43      23  100011
     36      44      24  100100
     37      45      25  100101
     38      46      26  100110
     39      47      27  100111
     40      50      28  101000
     41      51      29  101001
     42      52      2A  101010
     43      53      2B  101011
     44      54      2C  101100
     45      55      2D  101101
     46      56      2E  101110
     47      57      2F  101111
     48      60      30  110000
     49      61      31  110001
     50      62      32  110010
     51      63      33  110011
     52      64      34  110100
     53      65      35  110101
     54      66      36  110110
     55      67      37  110111
     56      70      38  111000
     57      71      39  111001
     58      72      3A  111010
     59      73      3B  111011
     60      74      3C  111100
     61      75      3D  111101
     62      76      3E  111110
     63      77      3F  111111
     64     100      40 1000000
     65     101      41 1000001
     66     102      42 1000010
     67     103      43 1000011
     68     104      44 1000100
     69     105      45 1000101
     70     106      46 1000110
     71     107      47 1000111
     72     110      48 1001000
     73     111      49 1001001
     74     112      4A 1001010
     75     113      4B 1001011
     76     114      4C 1001100
     77     115      4D 1001101
     78     116      4E 1001110
     79     117      4F 1001111
     80     120      50 1010000
     81     121      51 1010001
     82     122      52 1010010
     83     123      53 1010011
     84     124      54 1010100
     85     125      55 1010101
     86     126      56 1010110
     87     127      57 1010111
     88     130      58 1011000
     89     131      59 1011001
     90     132      5A 1011010
     91     133      5B 1011011
     92     134      5C 1011100
     93     135      5D 1011101
     94     136      5E 1011110
     95     137      5F 1011111
     96     140      60 1100000
     97     141      61 1100001
     98     142      62 1100010
     99     143      63 1100011

任务：Tolik 是一家鞋店的老板。他的商店有很多鞋子。他有一份清单，上面列出了他店里每双鞋的尺码。有许多顾客只在收到所需尺寸的鞋子时才愿意支付一笔钱。

你的任务是计算托利克赚了多少钱。

第一行包含鞋子的数量。第二行包含商店中所有鞋码的空格分隔列表。第三行包含客户端的数量。以下行包含客户所需的鞋子尺寸和鞋子价格的空格分隔值。打印托利科夫赚的钱。

样本输入：

十

2 3 4 5 6 8 7 6 5 18

6

6 55

6 45

6 55

4 40

18 60

10 50

结论：

200

解释：客户 1：以 55 美元的价格购买了 6 号鞋。顾客 2：以 45 美元的价格购买了 6 号鞋。买家 3：尺寸 6 已无货，请勿购买。顾客 4：40 美元买了 4 号鞋。顾客 5：以 60 美元的价格购买了 18 码的鞋子。买家 6：没有尺寸 10，所以不要购买。

总收入 = 200

number_of_shoes = int(input())
all_shoe_size = set(map(int, input().split(' ')))
print(all_shoe_size)
number_of_clients = int(input())

lst1 = []
lst2 = []
lst3 = []
lst4 = []
lst5 = []
lst6 = []

for i in range(number_of_clients):
    a, b = map(int, input().split())
    lst1.append(a)
    lst1.append(b)
print(f'lst 1: {lst1}')
print(f'lst 2: {lst2}')

#10
#2 3 4 5 6 8 7 6 5 18
#6
#6 55   Купил обувь 6-го размера за 55 долларов
#6 45   Купил обувь 6-го размера за 45 долларов
#6 55   Размер 6 больше не доступен, поэтому не покупайте.
#4 40   Купил обувь четвертого размера за 40 долларов
#18 60  Купил обувь 18-го размера за 60 долларов
#10 50  Размер 10 недоступен, поэтому не покупайте

#200

如何在知道需要多少输入的情况下制作所需数量的列表？以及如何使用循环将值放入每个列表中？

问题：第一行包含一个整数 ，即订阅英文报纸的学生人数。第二行包含这些学生的卷号，以空格分隔。第三行包含订阅法国报纸的学生人数。第四行包含这些学生的卷号，以空格分隔。

打印至少订阅一份的学生总数。

输入示例：

9

1 2 3 4 5 6 7 8 9

9

10 1 2 3 11 21 55 6 8

输出示例：13

至少订阅一次的学生人数： 卷号： 并且在两组中，所以他们只算一次。因此，总数是学生。

面对不断向集合写入不同值\u200b\u200bof数的问题，有什么问题呢？

a = int(input())
print(f'a:{a}')
b = set(input())
print(f'set b:{b}')

c = int(input())
print(f'c:{c}')
d = set(input())

print(f'set d:{d}')
print(len((b)|(d)))

有两个细微差别：（1）如果列表中没有元素需要删除之前的其余元素，则列表不应更改。(2) 如果列表为空，则它必须保持为空。

def remove_all_before(items: list, border: int) -> Iterable:
    if border in items:
        for i in range(len(items)):
            if items != border:
                items.remove(items[i])
            a = i
            items.remove(items[a])    
            return items
        else:
            return items
    else:
        return items        


print((remove_all_before([1, 2, 3, 4, 5], 3))) #[3, 4, 5]
print((remove_all_before([1, 1, 2, 2, 3, 3], 2))) #[2, 2, 3, 3]
print((remove_all_before([1, 1, 2, 4, 2, 3, 4], 2))) #[2, 4, 2, 3, 4]
print((remove_all_before([1, 1, 5, 6, 7], 2))) #[1, 1, 5, 6, 7]
print((remove_all_before([], 0))) #[]
print((remove_all_before([7, 7, 7, 7, 7, 7, 7, 7, 7], 7))) #[7, 7, 7, 7, 7, 7, 7, 7, 7]

我不知道如何通过七人制的最后一次检查，不再可能制作三明治并帮助我在 lambda 表达式中呈现这段代码（在打印右侧的注释中应该是最终结果）

    num = 234500
    zero_count = str(num)[::-1]
    count = 0
    for i in (range(0, len(zero_count))):
        while zero_count[i] != '1':
            count = count + 1
    print(count)