CodeFuse-MFTCoder提升Qwen-14B代码能力

from typing import List
def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ Filter an input list of strings only for ones that contain given substring
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """

return [s for s in strings if substring in s]

from typing import List
def below_zero(operations: List[int]) -> bool:
    """ You're given a list of deposit and withdrawal operations on a bank account that starts with
    zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
    at that point function should return True. Otherwise it should return False.
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """

balance = 0 for op in operations: balance += op if balance < 0: return True return False

/*
You"re given a vector of deposit and withdrawal operations on a bank account that starts with
zero balance. Your task is to detect if at any point the balance of account falls below zero, and
at that point function should return true. Otherwise it should return false.
>>> below_zero({1, 2, 3})
false
>>> below_zero({1, 2, -4, 5})
true
*/
#include<stdio.h>
#include<vector>
using namespace std;
bool below_zero(vector<int> operations){

int balance = 0; for(int i=0; i<operations.size(); i++){ balance += operations[i]; if(balance < 0){ return true; } } return false; }

/*
Filter an input vector of strings only for ones that contain given substring
>>> filter_by_substring({}, "a")
{}
>>> filter_by_substring({"abc", "bacd", "cde", "vector"}, "a")
{"abc", "bacd", "vector"}
*/
#include<stdio.h>
#include<vector>
#include<string>
using namespace std;
vector<string> filter_by_substring(vector<string> strings, string substring){

vector<string> filtered_strings; for(string s : strings){ if(s.find(substring) != string::npos){ filtered_strings.push_back(s); } } return filtered_strings; }

import java.util.*;
import java.lang.*;
class Solution {
    /**
    You're given a list of deposit and withdrawal operations on a bank account that starts with
    zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
    at that point function should return True. Otherwise it should return False.
    >>> belowZero(Arrays.asList(1, 2, 3))
    false
    >>> belowZero(Arrays.asList(1, 2, -4, 5))
    true
     */
    public boolean belowZero(List<Integer> operations) {

int balance = 0; for (int op : operations) { balance += op; if (balance < 0) { return true; } } return false; } }

import java.util.*;
import java.lang.*;
class Solution {
    /**
    Filter an input list of strings only for ones that contain given substring
    >>> filterBySubstring(List.of(), "a")
    []
    >>> filterBySubstring(Arrays.asList("abc", "bacd", "cde", "array"), "a")
    ["abc", "bacd", "array"]
     */
    public List<String> filterBySubstring(List<String> strings, String substring) {

List<String> filteredStrings = new ArrayList<>(); for (String str : strings) { if (str.contains(substring)) { filteredStrings.add(str); } } return filteredStrings; } }

/* You're given a list of deposit and withdrawal operations on a bank account that starts with
  zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
  at that point function should return true. Otherwise it should return false.
  >>> belowZero([1, 2, 3])
  false
  >>> belowZero([1, 2, -4, 5])
  true
  */
const belowZero = (operations) => {

let balance = 0; for (let i = 0; i < operations.length; i++) { balance += operations[i]; if (balance < 0) { return true; } } return false; };

/* Filter an input list of strings only for ones that contain given substring
  >>> filterBySubstring([], 'a')
  []
  >>> filterBySubstring(['abc', 'bacd', 'cde', 'array'], 'a')
  ['abc', 'bacd', 'array']
  */
const filterBySubstring = (strings, substring) => {

return strings.filter(string => string.includes(substring)); };

// You're given a list of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return true. Otherwise it should return false.
// >>> BelowZero([1, 2, 3])
// false
// >>> BelowZero([1, 2, -4, 5])
// true
func BelowZero(operations []int) bool {

balance := 0 for _, op := range operations { balance += op if balance < 0 { return true } } return false }

import (
    "fmt"
)
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// >>> StringXor('010', '110')
// '100'
func StringXor(a string, b string) string {

var result string for i := 0; i < len(a); i++ { if a[i] != b[i] { result += "1" } else { result += "0" } } return result

def has_duplicate(nums):
    return len(set(nums)) != len(nums)

```python def find_Product(arr, n): product = 1 for i in range(n): if arr[i] not in arr[:i] and arr[i] not in arr[i+1:]: product *= arr[i] return product ```

为以下Python代码生成单元测试
def total_match(lst1, lst2):
    l1 = 0
    for st in lst1:
        l1 += len(st)
    l2 = 0
    for st in lst2:
        l2 += len(st)
    if l1 <= l2:
        return lst1
    else:
        return lst2

import unittest
class TestTotalMatch(unittest.TestCase):
    def test_equal_length(self):
        # 测试两个列表长度相等的情况
        lst1 = ["abc", "def", "ghi"]
        lst2 = ["abc", "def", "jkl"]
        self.assertEqual(total_match(lst1, lst2), lst1)
    def test_different_length(self):
        # 测试两个列表长度不相等的情况
        lst1 = ["abc", "def", "ghi"]
        lst2 = ["abc", "def"]
        self.assertEqual(total_match(lst1, lst2), lst2)
    def test_empty_list(self):
        # 测试两个列表都为空的情况
        lst1 = []
        lst2 = []
        self.assertEqual(total_match(lst1, lst2), lst1)
if __name__ == "__main__":
    unittest.main()

为以下Python代码生成单元测试
def add_elements(arr, k):
    return sum(elem for elem in arr[:k] if len(str(elem)) <= 2)

import unittest
class TestAddElements(unittest.TestCase):
    def test_add_elements_with_k_0(self):
        # 测试当k为0时,返回0
        arr = [1, 2, 3, 4, 5]
        k = 0
        result = add_elements(arr, k)
        self.assertEqual(result, 0)
    def test_add_elements_with_k_1(self):
        # 测试当k为1时,返回1
        arr = [1, 2, 3, 4, 5]
        k = 1
        result = add_elements(arr, k)
        self.assertEqual(result, 1)
    def test_add_elements_with_k_2(self):
        # 测试当k为2时,返回1+2=3
        arr = [1, 2, 3, 4, 5]
        k = 2
        result = add_elements(arr, k)
        self.assertEqual(result, 3)
if __name__ == '__main__':
    unittest.main()

# Translate the following C++ program to Python
# C++
#include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
int hex_key(string num){
    string key="2357BD";
    int out=0;
    for (int i=0;i<num.length();i++)
        if (find(key.begin(),key.end(),num[i])!=key.end()) out+=1;
    return out;
}
# Python

def hex_key(num):
    key = "2357BD"
    out = 0
    for i in range(len(num)):
        if num[i] in key:
            out += 1
    return out

# Translate the following Python program to C++
 # Python
def check_Validity(a,b,c):  
    if (a + b <= c) or (a + c <= b) or (b + c <= a) : 
        return False
    else: 
        return True        
# C++
/**
* The result code must follow this signature:
* bool checkValidity(int a, int b, int c) 
*/

bool checkValidity(int a, int b, int c) {
    if (a + b <= c || a + c <= b || b + c <= a) {
        return false;
    } else {
        return true;
    }
}

# 除数为0时会抛出ZeroDivisionError异常
x = 10
y = 0
result = x / y  # 在这里会出现ZeroDivisionError异常
print(result)

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

# 添加判断语句,避免除数为0的情况
x = 10
y = 0
if y != 0:
    result = x / y
    print(result)
else:
    print("除数不能为0")

# 生成一个长度为10的列表
my_list = [i for i in range(10)]
# 对这个列表进行排序，但是使用了错误的参数
sorted_list = sorted(my_list, key=lambda x: 1/x)

Traceback (most recent call last):
 File "<stdin>", line 4, in <module>
ZeroDivisionError: division by zero

# 生成一个长度为10的列表
my_list = [i for i in range(10)]
# 对这个列表进行排序,但是使用了错误的参数
sorted_list = sorted(my_list, key=lambda x: 1/x if x!=0 else 0)