我试图学习游程长度编码，但是我在网上发现了我做不到的挑战。它要求您编写一个称为compression（strg）的压缩函数，该函数将长度为64的二进制字符串strg作为输入，并返回另一个二进制字符串作为输出。输出二进制字符串应为输入字符串的游程长度编码。
压缩（'1010101001010101101010100101010110101010010101011010101001010101'）
'1010101001010101 * 4'
这是我所拥有的，但是找不到该模式：
from itertools import *
def compression(strg):
return [(len(list(group)),name) for name, group in groupby(strg)]
我需要一些帮助来解决这个问题。
我有这样的数据集,
dat <- data.frame(d1=c(0,1,0,1,0),
d2=c(0,1,1,1,0),d3=c(1,0,1,1,0),
d4=c(1,0,0,0,0),d5=c(1,1,1,0,0))
dat
d1 d2 d3 d4 d5
1 0 0 1 1 1
2 1 1 0 0 1
3 0 1 1 0 1
4 1 1 1 0 0
5 0 0 0 0 0
如果我认为每一行都是为个人设定的.我想基于run计算一个名为"indicator"的指标变量.例如,对于这个向后运行的长度,单个1运行是(0,0,1,1,1),其中值1是3.另一方面,对于个体3运行是(0,1,1,0, 1),向后运行长度值为1,s为1.所需数据集如下.
d1 d2 d3 d4 d5 indicator
0 0 1 1 1 3
1 1 0 0 1 1
0 1 1 0 1 1
1 1 1 0 0 3
0 0 0 0 0 0 …让我们说我有一个像这样的Rle,长度为10:
b = rle(c("H", "T", "T", "H", "H", "H", "H", "H", "T", "H"))
如何在不使用的情况下获取此对象的长度inverse.rle？
length(inverse.rle(b))
# 10
我有一些代表染色体的稀疏Rles,它们可以有数亿的长度,所以我宁愿不使用逆.
akruns答案对我的数据不起作用:
> a
$ mydata
numeric-Rle of length 57442693 with 12471 runs
Lengths: 2709826 100 31062 100 ... 2 232 100 47
Values : 0 1 0 1 ... 1 0 1 0
> a$lengths
NULL
我想编写一个函数，它接受压缩的字符串并输出解压缩的字符串。
压缩字符串如a2b2c3和解压缩字符串aabbccc
更多示例是
`a` -> `a`
`ab12` -> `abbbbbbbbbbbb`
`a3b2a2` -> `aaabbaa
我尝试实现它，但对于像这样的压缩字符串来说，它确实很混乱且有缺陷ab12
function isNumeric(num) {
if (num === '') return false
if (num === null) return false
return !isNaN(num)
}
function decompress(compressedStr) {
const array = compressedStr.split('')
let prevChar, str = ''
for(let i = 0; i < array.length; i++) {
if(i === 0) {prevChar = array[i]}
if(isNumeric(array[i])) {
str += prevChar.repeat(Number(array[i]))
prevChar = null
} else {
if(!prevChar) prevChar = array[i]
else {
str …我正在尝试优化运行长度编码.我在考虑在SIMD中实现它.我花了几个小时在算法上工作,但不能继续下去.是否值得一试？我在做霓虹灯.
谢谢.
考虑A = [ 200000 x 1]矢量.我有另一个矢量idx = [200000x1].我想平铺A这样ithA的每个元素都是平铺idx(i)时间.
例如:
A idx output
2 2 2
3 1 2
4 3 3
5 1 4
. . 4
. . 4
. . 5
. . .
任何非循环的想法？
我想知道我们可以在多大程度上进行无损数据压缩；我无法找到无损算法的在线模拟器来执行一些经验测试。我可以自己做一个，但不幸的是我这段时间没有足够的时间；我仍然对我的直觉很好奇，我将对此进行解释。
让我们仅采用两种更流行的算法：Huffman Coding和Run-lenght Enconding。
假设我们有一个数字A符号的字母表和来自该字母表的任意长的符号序列：例如：
Alphabet = {A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, W, Y, Z}
Sequence1 = SFBJNERUSNJGSDKKDEIJGNMSDJDDSUSJNF
Sequence2 = MNMNMNREGUHSDFJUF
Sequence3 = MMMMMNNNNNASDUERJGASIUJMMMNNNUNS
现在，如果我们只用一个固定长度的n比特字对每个符号进行编码，我们就会得到未压缩的序列，即长N比特。
如果我们使用 Huffman 编码一个序列，我们将使用H位而不是N位，从而节省(1-H/N)*100%位空间。
如果我们使用 RLE 编码相同的序列，我们将使用R位，节省(1-R/N)*100%.
我想知道，如果我们申请RLE + Huffman或者Huffman + RLE我们可以比仅使用其中之一节省更多空间会发生什么。
对我来说，这似乎是一个非常基本的想法，但是在谷歌上搜索我没有找到关于这个主题的任何有趣的东西。
编辑： …
compression lossless-compression huffman-code data-compression run-length-encoding
我遇到了一个面试问题:
给定输入String :
aaaaabcddddee,将其转换为a5b1c1d4e2.
一个额外的约束是,这需要就地完成,意味着不应该使用额外的空间(数组).
保证编码的字符串始终适合原始字符串.换句话说,字符串abcde就不会出现,因为它将被编码为a1b1c1d1e1占用比原始字符串更多的空间.
一个提示采访者给我的是一次遍历字符串并找到保存的空间.
我有时会陷入困境,不使用额外的变量,输入字符串中的某些值可能会被覆盖.
任何建议将不胜感激？
以这种方式转换字符串
let initialString = "atttbcdddd"
// result must be like this "at3bcd4"
但重复次数必须大于2.例如,如果我们有"aa",结果将是"aa",但如果我们有"aaa",结果将是"a3"
还有一个例子:
let str = "aahhhgggg"
//result "aah3g4"
我的尝试:
func encrypt(_ str: String) -> String {
let char = str.components(separatedBy: "t") //must input the character
var count = char.count - 1
var string = ""
string.append("t\(count)")
return string
}
如果我输入"ttttt"它将返回"t5"但我应该输入该字符
我不知道这种类型的压缩是否在其他地方使用,但这是它的工作原理.它使用4个字符.第一个字符"ú"表示压缩紧随其后.接下来的两个字符在HEX中表示要重复的第四个位置中有多少个.例如:
22ú05hú0C0AFC001
将会:
22hhhhh000000000000AFC001
我能够做到这一点,但它运行得很慢.20k文件可能需要5分钟或更长时间.
这是我的代码:
public string doDecompression(string Content)
{
string pattern = @"ú...";
Regex rgx = new Regex(pattern);
foreach (Match match in rgx.Matches(Content))
{
// Gets the raw Hex code
string hex = match.ToString().Substring(1, 2);
// Converts Hex code to an Integer
int convertedHex = Int32.Parse(hex, NumberStyles.HexNumber);
// Gets the character to repeat
string character = match.ToString().Substring(3, 1);
// Converts the character to repeat into
// a "char" so I can use it in the line below
char …