Anthropic发布了Claude 2，这是其AI模型的新迭代，以进行Chatgpt和Google bard to Heathead。
在本文中，我将Claude 2与Claude 1.3和GPT-4进行了比较，以找出哪个具有更好的编码功能。
如果您想知道结果，那么本文适合您！
但是在我们潜水之前，让我简要介绍每个模型。
Claude 1.3
Claude 1.3，由拟人化开发，是一种以安全为中心的方法而闻名的AI语言模型。在大量资金支持下，Claude 1.3展示了编码和自然语言处理的高级功能，反映了人类对头对负责人AI开发的承诺。
Claude 2
Anthropic的Claude 2是一种强大的AI语言模型，超过了其前身。 Claude 2具有多达100,000个的代币能力，提供了更加上下文准确的响应。它在各个领域中都擅长，在法律，数学和编码方面得分高，展示了其先进的计算技能和多功能性。
GPT-4
gpt-4是OpenAI的GPT系列中最新的，它代表了AI语言模型的重大飞跃。逻辑推理，科学知识和文本生成的进步使GPT-4成为自然语言处理中的变革力量，为增强聊天机器人，虚拟助手和内容生成能力铺平了道路。它的发行版产生了预期，并为语言建模技术的新时代设定了舞台。
要查看每个模型的良好，我们将为每个模型提供三个提示/问题/分析的三个模型，并根据以下因素进行评分：
- 代码的质量
- 解决方案的完整性
- 解释的质量
现在，让我们开始。
编码问题
第一提示：
设计并实施了一种有效的算法，用于查找两个字符串之间最长的常见子序列。
克劳德1.3
这是动态编程算法的实现，以找到Python中两个字符串之间最长的共同子序列：
def lcs(string1, string2):
# Create a matrix to store lengths of longest common subsequences
m = len(string1)
n = len(string2)
L = [[0 for x in range(n+1)] for y in range(m+1)]
# Build the matrix in bottom-up manner
for i in range(m+1):
for j in range(n+1):
if i == 0 or j == 0:
L[i][j] = 0
elif string1[i-1] == string2[j-1]:
L[i][j] = L[i-1][j-1] + 1
else:
L[i][j] = max(L[i-1][j], L[i][j-1])
# Backtrack to find the actual subsequence
index = L[m][n]
lcs = [""] * (index+1)
lcs[index] = ""
i = m
j = n
while i > 0 and j > 0:
if string1[i-1] == string2[j-1]:
lcs[index-1] = string1[i-1]
i -= 1
j -= 1
index -= 1
elif L[i-1][j] > L[i][j-1]:
i -= 1
else:
j -= 1
return "".join(lcs)
关键步骤是：
- 创建一个矩阵来存储最长常见子序列的长度。
- 通过考虑所有可能的情况，以自下而上的方式构建矩阵。
- 基于矩阵以找到实际LCS的回溯。
时间复杂性为O（mn），其中m和n是输入字符串的长度，因为我们在整个矩阵上迭代。空间复杂性为O（mn）存储矩阵。
让我知道您是否希望我更详细地解释或浏览实施的任何部分！
我的评论：
总体而言，该代码是用于查找最长常见子序列的动态编程算法的良好实现。
这是我喜欢的一些特定内容：
- 评论清晰有用。
- 代码的结构是合乎逻辑且易于遵循的。
- 代码的格式很好。
这是一些可以改进的特定内容：
- 可以通过使用更紧凑的语法使代码更简洁。
- 可以更彻底地测试该代码。
克劳德2
这是一种有效的算法，用于在两个字符串之间找到最长的常见子序列（LCS）：
def lcs(X, Y):
m = len(X)
n = len(Y)
# construct a matrix to store lengths of LCS
L = [[0 for j in range(n+1)] for i in range(m+1)]
# fill the matrix in bottom up manner
for i in range(m+1):
for j in range(n+1):
if i == 0 or j == 0:
L[i][j] = 0
elif X[i-1] == Y[j-1]:
L[i][j] = L[i-1][j-1] + 1
else:
L[i][j] = max(L[i-1][j], L[i][j-1])
# L[m][n] contains the length of LCS
return L[m][n]
这实现了查找LCS的经典动态编程方法。关键步骤是：
- 初始化尺寸的矩阵L（M+1）x（n+1）以存储LCS的长度。
- 通过比较x和y的字符以自下而上的方式填充矩阵。
- 如果字符匹配，请以对角线值并添加1。
- 如果字符不匹配，请在顶部和左上最大值。
- l [m] [n]包含LCS的长度。
该算法在O（MN）时间和O（MN）空间中运行。通过仅存储L的电流和以前的L，可以将空间优化为O（n）。
该算法的一些关键优势是：
- 最佳子结构属性用于构建解决方案迭代
- 比幼稚的递归方法更有效
- 轻松扩展以打印出实际的LCS序列
让我知道您是否需要任何澄清或还有其他问题！
我的评论：
Claude 2提供了更多的空间效率代码。这是因为它仅存储矩阵的当前和以前的行，而不是整个矩阵。 它也很容易理解，但不像Claude 1.3答案那样容易理解。
GPT-4
设计一种有效的算法，用于在两个字符串之间找到最长的共同子序列（LC），我们可以使用动态编程。该算法将具有O（mn）的时间复杂性，其中m和n是输入字符串的长度。
这是Python中算法的实现：
def longest_common_subsequence(str1, str2):
m = len(str1)
n = len(str2)
# Create a matrix to store the lengths of LCS
lcs_matrix = [[0] * (n + 1) for _ in range(m + 1)]
# Compute the lengths of LCS for all subproblems
for i in range(1, m + 1):
for j in range(1, n + 1):
if str1[i - 1] == str2[j - 1]:
lcs_matrix[i][j] = lcs_matrix[i - 1][j - 1] + 1
else:
lcs_matrix[i][j] = max(lcs_matrix[i - 1][j], lcs_matrix[i][j - 1])
# Retrieve the LCS by backtracking through the matrix
lcs = ""
i, j = m, n
while i > 0 and j > 0:
if str1[i - 1] == str2[j - 1]:
lcs = str1[i - 1] + lcs
i -= 1
j -= 1
elif lcs_matrix[i - 1][j] > lcs_matrix[i][j - 1]:
i -= 1
else:
j -= 1
return lcs
现在，让我们用一个示例测试算法：
str1 = "AGGTAB"
str2 = "GXTXAYB"
lcs = longest_common_subsequence(str1, str2)
print(lcs) # Output: GTAB
该算法将输出两个输入字符串之间最长的常见子序列，在这种情况下为gtab。
我的评论：
比Claude 1.3和2更好。它具有高效，太空效率且易于理解。该代码被充分发音且格式很好，并且算法很容易扩展以打印出实际的LCS序列。
第二提示：
实现一个加密算法，例如RSA或AES进行安全数据加密和解密。
克劳德1.3
这是Python中的RSA公钥密码系统进行加密和解密的实现：
import random
import math
# Generate large random primes p and q
def generate_primes():
p = get_random_prime(100)
q = get_random_prime(100)
return p, q
# Get a random n-bit prime number
def get_random_prime(n):
while True:
num = random.randrange(2**(n-1), 2**n)
if isPrime(num):
return num
# Test if a number is prime
def isPrime(num):
if num < 2:
return False
for i in range(2, int(math.sqrt(num))+1):
if num % i == 0:
return False
return True
# Compute gcd to ensure p and q are coprime
def gcd(p, q):
while q != 0:
p, q = q, p % q
return p
# Generate encryption and decryption keys
def generate_keys(p, q):
n = p * q
phi = (p-1) * (q-1)
# Choose encryption key between 1 and phi
e = random.randrange(1, phi)
g = gcd(e, phi)
while g != 1:
e = random.randrange(1, phi)
g = gcd(e, phi)
# Compute decryption key
d = pow(e, -1, phi)
return ((n, e), (n, d))
# Encrypt message m
def encrypt(pk, m):
n, e = pk
c = pow(m, e, n)
return c
# Decrypt cipher c
def decrypt(sk, c):
n, d = sk
m = pow(c, d, n)
return m
# Driver code
p, q = generate_primes()
public, private = generate_keys(p, q)
message = 123456
encrypted = encrypt(public, message)
decrypted = decrypt(private, encrypted)
print("Original Message:", message)
print("Encrypted:", encrypted)
print("Decrypted:", decrypted)
关键步骤是：
- 生成大型随机素数P和Q
- 计算n = pq和phi =（p-1）（q-1）
- 选择加密密钥
- 计算解密密钥D使得Ed€1（Mod Phi）
- 加密消息m作为c = m^e（mod n）
- 解密密码C作为m = c^d（mod n）
这实现了用于公共密钥加密的核心RSA算法。我们可以使用较大的键尺寸，随机加密填充，键拆分等进一步提高安全性。
我的评论：
该代码经过良好的评估且格式很好，很容易理解算法的关键步骤。可以通过使用较大的钥匙尺寸，随机加密填充和键拆分来改进任务。这些技术可以进一步提高RSA算法的安全性。
克劳德2
这是Python中AES加密算法的示例实现：
import base64
from Crypto.Cipher import AES
key = b' sixteen byte key'
def encrypt(raw):
raw = pad(raw)
cipher = AES.new(key, AES.MODE_ECB)
enc = cipher.encrypt(raw)
return base64.b64encode(enc).decode('utf-8')
def decrypt(enc):
enc = base64.b64decode(enc)
cipher = AES.new(key, AES.MODE_ECB)
dec = cipher.decrypt(enc)
return unpad(dec).decode('utf-8')
def pad(s):
return s + (16 - len(s) % 16) * chr(16 - len(s) % 16)
def unpad(s):
return s[:-ord(s[len(s)-1:])]
plaintext = 'secret message'
ciphertext = encrypt(plaintext)
decrypted = decrypt(ciphertext)
print(f'Plaintext: {plaintext}')
print(f'Ciphertext: {ciphertext}')
print(f'Decrypted: {decrypted}')
这将AES在欧洲央行模式下实现，将明文填充到16个字节块。指定了16个字节随机密钥。密文是在输出之前编码的base64。
对于RSA，我们需要生成一个公共/私钥对，使用公共密钥加密，使用私钥解密。这是RSA实现的示例：
from Cryptodome.PublicKey import RSA
key = RSA.generate(2048)
private_key = key.export_key()
public_key = key.publickey().export_key()
plaintext = 'secret message'
ciphertext = public_key.encrypt(plaintext.encode('utf-8'), 32)
decrypted = private_key.decrypt(ciphertext)
print(decrypted.decode('utf-8'))
这将生成一个新的2048位RSA键，然后用公共密钥对明文进行加密，并用私钥加密。
这些只是简单的示例，但用AES和RSA在Python中说明了加密/解密数据。生产系统所需的关键生成，操作模式，填充方案等方面有许多选择和最佳实践。
我的评论：
Claude 2在Python中实现了用于对称密钥加密的AES算法。它比RSA算法更简单，并且更有效。但是，它不像RSA算法那样安全。
该代码经过良好的评估且格式很好，很容易理解算法的关键步骤。但是，可以使用较大的钥匙尺寸来改进它。
GPT-4
当然！我可以为您提供RSA和AES加密和解密算法的高级概述和代码示例。让我们从RSA开始。
RSA（Rivest-Shamir-Adleman）是一种不对称的加密算法，广泛用于安全数据传输和数字签名。它涉及使用公钥进行加密和解密的私钥。
这是如何使用Python中的密码库来生成RSA键，加密和解密数据的一个示例：
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import serialization, hashes
# Generate RSA key pair
private_key = rsa.generate_private_key(
public_exponent=65537,
key_size=2048
)
public_key = private_key.public_key()
# Serialize and save private key
private_pem = private_key.private_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PrivateFormat.PKCS8,
encryption_algorithm=serialization.NoEncryption()
)
with open('private_key.pem', 'wb') as f:
f.write(private_pem)
# Serialize and save public key
public_pem = public_key.public_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PublicFormat.SubjectPublicKeyInfo
)
with open('public_key.pem', 'wb') as f:
f.write(public_pem)
# Encrypt data using the public key
data = b"Hello, World!"
ciphertext = public_key.encrypt(
data,
padding.OAEP(
mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None
)
)
print("Encrypted data:", ciphertext.hex())
# Decrypt data using the private key
plaintext = private_key.decrypt(
ciphertext,
padding.OAEP(
mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None
)
)
print("Decrypted data:", plaintext.decode())
现在让我们继续使用AES（高级加密标准），这是一种对称加密算法，用于安全数据存储和传输。
AES在固定大小的数据块上运行，并使用对称键进行加密和解密。
这里是使用Python中的加密图书馆的AES加密和解密的一个例子：
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
# Generate a random AES key
key = b'Sixteen byte key' # Change this to your own key
# Generate a random initialization vector (IV)
iv = b'Initialization V' # Change this to your own IV
# Encrypt data using AES-CBC mode
plaintext = b"Hello, World!"
backend = default_backend()
cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=backend)
encryptor = cipher.encryptor()
ciphertext = encryptor.update(plaintext) + encryptor.finalize()
print("Encrypted data:", ciphertext.hex())
# Decrypt data using AES-CBC mode
decryptor = cipher.decryptor()
decrypted_data = decryptor.update(ciphertext) + decryptor.finalize()
print("Decrypted data:", decrypted_data.decode())
记住根据您的特定用例处理密钥管理，安全密钥交换和其他安全考虑。
请注意，此处提供的示例是出于教育目的，可能不能涵盖安全实施的所有方面。对于实际情况，建议使用经过良好测试和值得信赖的加密库或咨询安全专业人员。
让我知道您是否需要进一步的帮助！
我的评论：
比Claude 1.3和Claude 2更好，因为它同时提供了RSA和AES加密和解密算法。它还使用RSA中的OAEP填充方案，这是一个安全的填充方案，有助于防止攻击。
除此之外，它使用了AES中的CBC操作模式，这是一种安全的操作模式，有助于防止攻击。
第三提示：
创建一个生成给定字符串的所有可能组合的函数。例如，鉴于字符串，该功能应以所有可能的组合返回数组： ，Acâ，bcâ，Abcâ]。
克劳德1.3
这是一个python函数，可以生成给定字符串的所有可能组合：
def generate_combinations(string):
results = []
n = len(string)
# Generate all 2^n possible combinations
for i in range(2**n):
combo = []
for j in range(n):
if (i >> j) % 2 == 1:
combo.append(string[j])
results.append(''.join(combo))
return results
关键步骤是：
- 计算2^n，其中n是输入字符串的长度。这为我们提供了可能的组合总数。
- 循环通过0到2^n的数字1.每个数字代表一个唯一的二进制字符串，指示每个组合中包含哪些字符。
- 将数字转换为二进制。从右到左检查每一点。如果位是1，则将该字符附加到当前组合。
- 加入角色并将每个组合添加到结果列表中。
例如，对于ABC：
- 有2^3 = 8可能的组合
- 循环从0（二进制中的000）到7（二进制111）
- 000 = a，001 = b，010 = c，011 = ab，等等。
- 附加每个组合并返回所有8个组合
时间复杂性为o（n * 2^n），因为我们从0到2^n并创建每个组合。
让我知道您是否需要任何澄清或还有其他问题！
我的评论：
Claude 1.3实现了Python函数，以生成给定字符串的所有可能组合。该功能受到良好的评价，易于理解。算法的关键步骤得到了很好的解释。
该函数使用简单有效的算法来生成所有可能的组合。该算法通过循环循环到所有2 n可能的组合，其中n是输入字符串的长度。
可以通过使用更有效的数据结构来改进该函数，但是对于大多数应用程序，当前的实现仍然足够。
。克劳德2
这是一个生成给定字符串的所有可能组合的函数：
from itertools import combinations
def get_combinations(string):
combinations = []
for i in range(1, len(string)+1):
combinations += list(combinations(string, i))
return combinations
分解：
- 从Itertools模块导入组合函数。这将使我们能够有效地生成所有组合。
- 创建一个空列表来存储结果。
- 使用一个用于循环从1到字符串 + 1的长度迭代。这将生成从长度为1到字符串长度的所有组合。
- 对于每次迭代，使用组合（字符串，i）获取长度i的所有组合。
- 将结果附加到组合列表中。
- 循环后，返回包含所有可能组合的组合列表。
测试它：
print(get_combinations("abc"))
# ['a', 'b', 'c', 'ab', 'ac', 'bc', 'abc']
因此，这通过利用itertools的功率来生成所有可能的组合。梳理能够有效地获取每次迭代中所需长度的子集。
我的评论：
比Claude 1.3好。 Claude 1.3使用了组合的二进制表示，该组合效率较低，但Claude 2使用了Itertools.Combinations函数，比使用组合的二进制表示更有效。组合函数需要两个参数：字符串和组合的长度。该功能返回指定长度的字符串的所有组合列表。
GPT-4
这是一个python的实现，该函数生成给定字符串的所有可能组合：
def generate_combinations(s):
combinations = []
# Helper function to generate combinations recursively
def generate_helper(substring, index):
if index == len(s):
combinations.append(substring)
return
# Exclude the current character
generate_helper(substring, index + 1)
# Include the current character
generate_helper(substring + s[index], index + 1)
generate_helper("", 0)
return combinations
# Example usage
input_string = "abc"
result = generate_combinations(input_string)
print(result)
输出：
css
Copy code
['', 'c', 'b', 'bc', 'a', 'ac', 'ab', 'abc']
函数生成_combinations将字符串S作为输入，并初始化一个名为Compinations的空列表以存储生成的组合。它还定义了辅助函数生成_helper，该函数将子字符串和索引作为参数。
generate_helper函数使用递归来生成组合。在每个步骤中，它都有两个选择：在索引处包括当前字符或排除该字符。它通过排除当前字符并将其包括在内，将其自称两次。当索引等于字符串的长度时，达到了基本情况，此时，它将生成的子字符串添加到组合列表中。
generate_combinations函数用空的初始子字符串和索引0调用辅助功能。最后，它返回包含输入字符串的所有可能组合的组合列表。
我的评论：
做得好！ GPT-4 使用递归生成给定字符串的所有可能组合。递归是减少错误的更好方法。
给出每个模型的评分
代码质量
| 模型 | 代码质量 | 评分 |
|---|---|---|
| Claude 1.3 | 足够的代码，但它可能缺乏其他模型中存在的一些改进和优化。 | 5 | 中的3个
| 克劳德2 | 高质量的代码，它展示了坚实的工程实践，并且结构良好。 | 4中的4个 |
| gpt-4 | 高级代码，比所有AI模型都在质量和优化方面更好。 | 5中的5 |
解决方案的完整性
| 模型 | 解决方案的完整性 | 评分 |
|---|---|---|
| Claude 1.3 | 不太全面，但其解决方案完成。 | 4中的4个 |
| 克劳德2 | 完整的解决方案，以更高的完整性解决了当前问题的各个方面。 | 4.5中的5 |
| gpt-4 | 全面解决了各种用户查询的解决方案，并具有出色的完整性。 | 5中的5 |
解释的质量
| 模型 | 解决方案的完整性 | 评分 |
|---|---|---|
| Claude 1.3 | 与其他相比3.5中的5 | |
| 克劳德2 | 更详细且信息丰富的解释，但仍然不如GPT-4。 | 4中的4个 |
| gpt-4 | 由于自然语言处理的进步， | 5中的5 |
结论
| AI模型得分 | 代码的质量评分范围（1 -5） | 解决方案的完整性得分范围（1 -5） | 解释的质量得分范围（1 -5） | 总分5 + 5 + 5 = 15 |
|---|---|---|---|---|
| Claude 1.3 | 3 Limited | 4好 | 3.5好 | 10.5平均 |
| 克劳德2 | 4好 | 4.5good | 4好 | 12.5好 |
| gpt-4 | 5优质 | 5优质 | 5优质 | 15总冠军 |
基于上述评级，GPT-4在编码功能方面是明显的赢家。它的分数最高：代码质量，解决方案的完整性和解释质量。
Claude 2是紧密的第二，在所有三个类别中的得分都很高。 Claude 1.3对于那些需要具有广泛文档的模型的人来说是一个不错的选择，但它不像Claude 2或GPT-4那样有效或容易理解。
总的来说，这三种型号都以自己的方式令人印象深刻。他们展示了大语言模型的力量及其与计算机互动方式的潜力。