Question

我对包含重复的字符串的逻辑结构感兴趣。我想出了一个我认为它应该可以运行的系统，但是我不确定这是最有效的。

这个想法很简单。第一个元素被采用：如果第二个元素是第一个元素的副本，我们将获得1次重复。我将其记录为一个重复，然后获取前两个元素，并检查它们是否在第三个和第四个元素中重复。

这样，我检查（从第一个元素到字符串的一半大小）是否存在重复的元素。最长的重复是优选的。之所以选择该选项，是因为这是一个递归过程：我检查重复内部是否还有其他重复。

如果未找到重复项，则裁剪第一个元素并重复该算法。

例如： “ ACRCRTCRCRTZZB” 在1'跑后变成： [{times：1，字符串：“ ACRCRTCRCRTZZB”}] 2'运行后： [{times：1，字符串：“ A”}，{times：2，字符串：“ CRCRT”}，{times：1，字符串：“ ZZB”}] 3分后： [{times：1，字符串：“ A”}，{times：2，字符串：[{times：2，字符串：“ CR”}，{times：1，字符串：“ T”}]]，{times：1 ，字符串：[{次：2，字符串：“ Z”}，{时间：1，字符串：“ B”}]}]

此表示法可能会造成混淆，但可以将其查看为： A [2 [2CR] T] [2Z] B 用于“ ACRCRTCRCRTZZB”

问题是一般性问题，与语言无关。我在python中为此编写了初始代码，并在后端考虑了其解决方案。还有一个javascript解决方案（如果在前端解决了）将对我有用。

测试

# -*- coding: utf-8 -*-
import unittest
from string_repetitions import StrPattern as sp

class TestStringRepetitions(unittest.TestCase):


    def setUp(self):
        self.str_ptrn = sp() 


    pass


    def test_fromStr2Tpl(self):
        str_ptrn = sp()


        a_li = []
        a_tpl = []
        b_li = [0, 1, 0, 1, ]
        b_tpl = [(0, 1), (0, 1), ]
        c_li = [0, 1, 3, 4, 4, 3, 3, 4, 4, 3]
        c_tpl = [(0, 1), (3, 4), (4, 3), (3, 4), (4, 3)]
        d_li = [0, 1, 3, 4, 2, 1, 1, 4]
        d_tpl = [(0, 1), (3, 4), (2, 1), (1, 4)]
        e_li = [0, 1, 3, ]
        e_tpl = None

        self.assertEqual(self.str_ptrn.fromStr2Tpl(a_li), a_tpl)
        self.assertEqual(self.str_ptrn.fromStr2Tpl(b_li), b_tpl)
        self.assertEqual(self.str_ptrn.fromStr2Tpl(c_li), c_tpl)
        self.assertEqual(self.str_ptrn.fromStr2Tpl(d_li), d_tpl)
        self.assertEqual(self.str_ptrn.fromStr2Tpl(e_li), e_tpl)


    def test_logic(self):
        a1_li = [(0, 1)]  # only one row


        a1_lo = [{"times": 1, "rows": [(0, 1), ]}, ]
        b0_li = [(0, 1), (0, 1)]
        b0_lo = [{"times": 2, "rows": [(0, 1)]}]
        b1_li = [(0, 1), (0, 1), (0, 1), (0, 1), (0, 1), ]
        b1_lo = [{"times": 5, "rows": [(0, 1)]}]
        b2_li = [(0, 1), (4, 3)]  # two row not repeated
        b2_lo = [{"times": 1, "rows": [(0, 1), (4, 3), ]}, ]
        c0_li = [(3, 4), (4, 3), (3, 4), (4, 3)]
        c0_lo = [{"times": 2, "rows": [(3, 4), (4, 3)]}]
        d0_li = [(0, 1), (3, 4), (2, 1), (1, 4)]
        d0_lo = [{"times": 1, "rows": [(0, 1), (3, 4), (2, 1), (1, 4), ]}, ]
        e0_li = [(0, 1), (3, 4), (4, 3), (3, 4), (4, 3)]
        e0_lo = [{"times": 1, "rows": [(0, 1)]}, {"times": 2, "rows": [(3, 4), (4, 3)]}]
        f0_li = [(0, 1), (3, 4), (2, 1), (1, 4)]
        f0_lo = [{"times": 1, "rows": [(0, 1), (3, 4), (2, 1), (1, 4)]}]

        self.assertEqual(self.str_ptrn.logic([]), [])
        self.assertEqual(self.str_ptrn.logic(a1_li), a1_lo)
        self.assertEqual(self.str_ptrn.logic(b0_li), b0_lo)
        self.assertEqual(self.str_ptrn.logic(b1_li), b1_lo)
        self.assertEqual(self.str_ptrn.logic(b2_li), b2_lo)
        self.assertEqual(self.str_ptrn.logic(c0_li), c0_lo)
        self.assertEqual(self.str_ptrn.logic(d0_li), d0_lo)
        # self.assertEqual(self.str_ptrn.logic(e0_li), e0_lo)

        '''
        def test_fromList2Logic(self):
        b1_li = [0, 1, 0, 1, 0, 1, 0, 1, 0, 1,]
        b1_lo = [{"times": 5, "rows": [(0, 1)]}]

        c0_li = [ 1, 0, 3, 4, 4, 3, 3, 4, 4, 3]
        c0_lo = [{"times": 1, "rows": [(1, 0), ]}, {"times": 2, "rows": [(3, 4), (4, 3)]}]

        d0_li = [1, 0, 0, 2, 4, 3, 4, 3, 0, 2, 4, 3, 4, 3]
        d0_lo = [{"times": 1, "rows": [(1, 0), ]},
        {"times": 2, "rows": [(0, 2),
        {"times": 2, "rows": [(4, 3)]},], }
        ]

        self.assertEqual(self.str_ptrn.logic(b1_li), b1_lo)
        '''

if name == 'main':
    unittest.main()

我编写的代码尚未完成：我想知道我是否正在以最佳方式解决这个问题。

减少元素重复的字符串的算法

0 个答案: