青训2_1106_01 环装DNA 序列的最小表示法_小c正在研究一种环状的 dna 结构,它由四种碱基a、c、g、t构成。这种环状结构的特-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_40266376/article/details/143582334

青训2_1106_01 环装DNA 序列的最小表示法 .md

文章目录

青训2_1106_01 环装DNA 序列的最小表示法 .md

一、问题描述

环状 DNA 序列的最小表示法
问题描述
小C正在研究一种环状的 DNA 结构，它由四种碱基A、C、G、T构成。这种环状结构的特点是可以从任何位置开始读取序列，因此一个长度为 n 的碱基序列可以有 n 种不同的表示方式。小C的任务是从这些表示中找到字典序最小的序列，即该序列的“最小表示”。

例如：碱基序列 ATCA 从不同位置读取可能的表示有 ATCA, TCAA, CAAT, AATC，其中 AATC 是字典序最小的表示。

1.1测试样例

样例1：

输入：dna_sequence = "ATCA"
输出：'AATC'

样例2：

输入：dna_sequence = "CGAGTC"
输出：'AGTCCG'

样例3：

输入：dna_sequence = "TTGAC"
输出：'ACTTG'

1.2 示例

def solution(dna_sequence):
    # Please write your code here
    return ""

if __name__ == "__main__":
    #  You can add more test cases here
    print(solution("ATCA") == "AATC")
    print(solution("CGAGTC") == "AGTCCG")
    print(solution("TCATGGAGTGCTCCTGGAGGCTGAGTCCATCTCCAGTAG") == "AGGCTGAGTCCATCTCCAGTAGTCATGGAGTGCTCCTGG")

二、答案

2.1 简略

def solution(dna_sequence):
    n = len(dna_sequence)
    # 将原序列复制一次，方便处理循环的情况
    doubled = dna_sequence + dna_sequence
    min_seq = dna_sequence
    
    # 尝试从每个位置开始的序列
    for i in range(n):
        # 截取长度为n的子串
        current = doubled[i:i+n]
        # 如果当前序列的字典序更小，则更新min_seq
        if current < min_seq:
            min_seq = current
            
    return min_seq

if __name__ == "__main__":
    #  You can add more test cases here
    print(solution("ATCA") == "AATC")
    print(solution("CGAGTC") == "AGTCCG")
    print(solution("TCATGGAGTGCTCCTGGAGGCTGAGTCCATCTCCAGTAG") == "AGGCTGAGTCCATCTCCAGTAGTCATGGAGTGCTCCTGG")

答案注释输出版本

def compare_strings_detailed(s1, s2):
    print(f"\n比较 '{s1}' 和 '{s2}':")
    
    # 获取最短长度
    min_len = min(len(s1), len(s2))
    
    # 逐字符比较
    for i in range(min_len):
        if s1[i] != s2[i]:
            print(f"在位置 {i}:")
            print(f"'{s1[i]}' (ASCII: {ord(s1[i])}) vs '{s2[i]}' (ASCII: {ord(s2[i])})")
            print(f"'{s1[i]}' {'<' if s1[i] < s2[i] else '>'} '{s2[i]}'")
            return s1 < s2
    
    # 如果前面字符都相同，比较长度
    if len(s1) != len(s2):
        print("前面字符都相同，比较长度")
        print(f"长度: {len(s1)} vs {len(s2)}")
        return len(s1) < len(s2)
    
    print("两个字符串完全相同")
    return False

# 测试DNA序列比较
def test_dna_comparisons():
    # 测试1：比较AATC和ATCA
    print("\n测试1:")
    result = compare_strings_detailed("AATC", "ATCA")
    print(f"'AATC' < 'ATCA' 是 {result}")
    
    # 测试2：比较不同长度的字符串
    print("\n测试2:")
    result = compare_strings_detailed("AAT", "AATC")
    print(f"'AAT' < 'AATC' 是 {result}")
    
    # DNA序列中的字符顺序演示
    print("\nDNA碱基顺序:")
    bases = ['A', 'C', 'G', 'T']
    for i in range(len(bases)):
        for j in range(i + 1, len(bases)):
            print(f"'{bases[i]}' < '{bases[j]}' 是 {bases[i] < bases[j]} (ASCII: {ord(bases[i])} < {ord(bases[j])})")

if __name__ == "__main__":
    test_dna_comparisons()

三、疑问

3.1、字典序是啥意思？以A为开头？

答：关于字典序(lexicographical order): 字典序就像字典里单词的排序方式。比如:

AATC 比 ATCA 的字典序小，因为第二个位置 A < T
就像 “apple” 在字典中排在 “banana” 前面一样
DNA序列中: A < C < G < T

答案：哦，那就是遍历所有可能结果，然后找出字母排序靠前的，如果相同，则取下一位靠前，以此类推。有n种方法排序

3.2、如何比较大小？我不懂 python关于数字/字母转换为数字 ascII码一样的东西吗还是通过别的方式比较_答：直接比较就可以，内置了方法，如下

在 Python 中，字符串比较是基于ASCII码（或Unicode码）值进行的，但你不需要手动转换 - Python会自动处理字符串比较。不过让我详细解释一下这个过程：

Python中的字符串比较:

# 直接比较字符串
print('A' < 'C')  # True
print('ABC' < 'ACC')  # True 

# 如果想知道ASCII值，可以用ord()函数
print(ord('A'))  # 65
print(ord('C'))  # 67
print(ord('G'))  # 71
print(ord('T'))  # 84

字符串比较规则:

从左到右逐个字符比较
遇到第一个不同的字符就决定了大小关系
如果前面都相同，较短的字符串小于较长的字符串

让我写一个更详细的演示代码：

让我运行一下这个示例，解释输出：

对于DNA序列 “AATC” 和 “ATCA” 的比较：

AATC vs ATCA
- 第一个字符都是'A'，继续比较
- 第二个字符：'A' < 'T'，所以 AATC < ATCA

DNA碱基的顺序：

A < C < G < T
因为它们的ASCII值：
A: 65
C: 67
G: 71
T: 84

！！！所以在原来的最小表示问题中 if current < min_seq ：min_seq = current

# 当我们写
if current < min_seq:
    min_seq = current

# Python实际上是在做：
# 1. 从左到右比较每个字符
# 2. 遇到第一个不同的字符就决定大小
# 3. 例如 'AATC' < 'ATCA' 是true，因为第二个位置 'A' < 'T'

这种比较方式是Python内建的，你不需要手动转换成ASCII码，Python会自动处理。这就是为什么我们可以直接用 < 来比较字符串。

要验证一个序列是否是最小表示，我们只需要把它和所有可能的旋转进行比较，如果它比所有其他旋转都小，那它就是最小表示。

3.3、doubled = dna_sequence + dna_sequence 的目的。答：先创建一个循环，那样遍历到原始片段最后一位时候，就是n个组合了。

假设输入序列是 “ATCA”：

doubled = dna_sequence + dna_sequence

dna_sequence = "ATCA"
doubled = "ATCA" + "ATCA" = "ATCAATCA"

这样做是为了方便处理循环。因为DNA是环状的，我们需要考虑所有可能的起始位置。

遍历过程演示：

n = 4  # 原序列长度
min_seq = "ATCA"  # 初始值

# i = 0 时:
current = doubled[0:4] = "ATCA"
# 比较: "ATCA" < "ATCA"? 否，不更新

# i = 1 时:
current = doubled[1:5] = "TCAA"
# 比较: "TCAA" < "ATCA"? 否，不更新

# i = 2 时:
current = doubled[2:6] = "CAAT"
# 比较: "CAAT" < "ATCA"? 否，不更新

# i = 3 时:
current = doubled[3:7] = "AATC"
# 比较: "AATC" < "ATCA"? 是，更新！
min_seq = "AATC"

让我写一个带详细打印的版本，帮助你理解：

解释为什么要这样做：

为什么要复制一次序列？
- 因为DNA是环状的，我们需要考虑所有可能的起始位置
- 通过复制一次，我们可以用简单的切片操作获取所有可能的旋转序列
- 比如对于"ATCA"：
  - 不复制的话，从位置3开始就无法获取完整的4个字符
  - 复制后"ATCAATCA"，就可以轻松获取"AATC"(从位置3开始)
为什么用切片 doubled[i:i+n]？
- i 是起始位置
- i+n 确保我们每次都获取原序列长度的字符
- 切片操作 [i:i+n] 会返回从位置i开始的n个字符
比较和更新过程
- 每次获取一个可能的序列后，与当前找到的最小序列比较
- 如果发现更小的，就更新 min_seq

这样我们就能找到所有可能旋转中字典序最小的那个序列。