字符串操作

今天非常无聊的决定去试一下python。找了一个题，大意如下：

给定一个输入字符串，找出最漂亮的无重复子字符串。
子字符串：从原字符串中减掉某些字符可得到的。
无重复字符串：没有重复的字符
甲比乙漂亮：甲的长度>乙，或者甲的字典排序在乙之后。

因为都是无重复的，所以肯定不需要甲的长度大于乙，故而是所有长度一样的无重复子字符串中，找出字典排序最大的。

这个先用R写的，为的是写出一个有效的算法来。基本的思路就是强行的逐层递归。

x = 'nlhthgrfdnnlprjtecpdrthigjoqdejsfkasoctjijaoebqlrgaiakfsbljmpibkidjsrtkgrdnqsknbarpabgokbsrfhmeklrle'

x_split = strsplit(x,split="")[[1]]
unique_x = unique(x_split) 
unique_x_order = sort(unique_x,decreasing=T) 
x_remain = character() 

# find the largest character than can be remained

#initialize
current_string = x_split
current_unique = unique_x
current_order = unique_x_order
while ( length(x_remain) < 20) 
{ 
  for(i in 1:length(current_order))
  { character = current_order[i]
    index = which(current_string == character)
    sub_string = current_string[min(index):length(current_string)]  
    if (length(setdiff(unique(current_string),unique(sub_string)))==0) #no lose of characters
    {x_remain = c(x_remain,character);
     current_string = current_string[-c(1:min(index),index)];
     current_unique = unique(current_string);
     current_order = sort(current_unique,decreasing=T);
     break;
    }
  }
}

#answer is 'tsocrpkijgdqnbafhmle'

后面用python重写了一遍。基本就是等价函数的替换...我是不是在暴殄天物的利用python？完全不理解program on the fly的感觉...

x = 'nlhthgrfdnnlprjtecpdrthigjoqdejsfkasoctjijaoebqlrgaiakfsbljmpibkidjsrtkgrdnqsknbarpabgokbsrfhmeklrle';
x_split = list(x);
unique_x = list(set(x_split));
unique_x.sort(reverse=True)
x_remain = list();
###initialize
current_string = x_split;current_unique = unique_x;current_order = unique_x;
while len(x_remain) < len(unique_x):
	for character in current_order:
		index = current_string.index(character);
		sub_string = current_string[index:len(current_string)];
		#print(character);
		if (len(set(current_string)-set(sub_string))==0): #no lose of characters
			x_remain.append(character);
			for i in range(sub_string.count(character)):
				sub_string.remove(character);
			current_string= sub_string;
			current_unique = list(set(current_string));
			current_unique.sort(reverse=True);
			current_order = current_unique;
			break;
print(x_remain);

最后好不容易写完python之后，发现网断了...没法在线提交了。等重新连上，时间已经过了，sigh。就当周末无聊历练一下了。

以前总是觉得不同的计算机语言之间只是语法问题，思路其实还是差不多的--后来才知道不尽然如此。比如用惯了R作分析，切换到其他语言顿时觉得效率降低了好多，尤其是很多一行命令在R里面就可以搞定的时候-思维习惯了一定程度的跳跃，常用的操作（尤其是数据整理！）封装成函数之后工作效率那叫一个倍增啊！结合knitr，原来的时候生成定期报告的效率极其之高，基本属于10倍以上的时间节省。

现在公司的数据平台是teradata，典型的SQL结构，各种join。在这么大的数据量下，不可能直接取数据到本机来分析，只能借助SQL进行一定程度的降维。而后剩下的收尾分析工作，可以由R完成。至于两者之间分工的界限在哪里，我还在摸索一个效率最高的平衡点。不得不吐槽一下，SQL的逻辑思维方式真心没效率，完全是为了数据库性能和空间单位平衡而设计的，做分析的时候就额外的痛苦许多——90%以上的时间都用来琢磨怎么鼓捣出来自己需要的数据格式，全在数据清理上了！

抱怨完毕，除了祈祷hadoopR和oracle连接起来彻底摆脱SQL阴影之外，暂时只能跟SQL硬战。下面说说最近常见的几个相同功能在R和SQL里面分别的实现方法。

1. 生成新变量

多见的明确的任务啊。如果是数值型，比如变量D是其他三个变量ABC的显性函数f(A,B,C)，最简单诸如D=A+B+C，在R和SQL里面都是直接写。

R：

my_dataframe$D <- my_dataframe$A+ my_dataframe$B + my_dataframe$C

（当然还有更elegant的with()函数）

SQL(以select为例):
```
SELECT A,B,C, A+B+C D from my_datatable;
```
然后如果f()稍稍复杂的话，R的可以定义函数的优势就明显了，SQL只有macro模式显然不足够灵活强大。如，

generate_D <- function(VarA=A, VarB=B, VarC=C) {
VarD <- VarA * VarB *(VarB %*% VarC)
return( VarD)}
my_dataframe$D <- generate_D(my_dataframe$A, my_dataframe$B, my_dataframe$C)

注：%*%代表向量内积或矩阵乘法，这里为一个数字。理论上这里可以调用任何R中函数。

如果新变量是字符型，R的优势就更明显了，字符串操作函数例如substr()取字符串其中一段，paste()连接多个字符串，grep()和sub()查找替换类，自然比SQL灵活的多。还是那句话，只要能用函数写出来，R都可以方便地搞定。你问我拿SQL跟R比这个有意思么？明显SQL就不是为了这个功能专门设计的啊。好吧，常见的生成新变量的情况：有条件的生成新变量，比如年龄分组等，基本就是按照若干已知条件生成一个新的变量。这里，SQL的case when确实方便，比如年龄分为老中青三组：

SQL:

SELECT CASE WHEN AGE>50 THEN 'old'
WHEN AGE between 25 and 50 THEN 'mid'
ELSE 'young'
END AGE_GROUP
FROM my_datatable

而R中，我一直用一种最笨的办法-刚刚搜了一下发现其实我的办法还是挺好用的。

My_dataframe$AGE_GROUP <- 'young'
My_dataframe[My_dataframe$AGE > 50,]$AGE_GROUP <- 'mid'
My_dataframe[(My_dataframe$AGE >=25 )& (My_datafame$AGE<= 50),]$AGE_GROUP <- 'mid'

当然也可以用ifelse()或者transform的方法，我倒是觉得没有这种笨办法清晰简洁易读，易于回头看代码。ifelse那堆括号哦！没有高亮匹配会死人的。

这里边界值随意，不考虑直接除法取整的情况。两种分类时可以直接用逻辑型简化，一行出结果；另，数值型离散化转换为factor型其实可以简单的用一个函数cut()搞定..（多谢yihui一语道破天机）

2. 分组加总等数据整理统计

要知道在很多时候，什么都比不上基本的求和均值方差有用，偶尔来个计数最大最小值就不错了。SQL一个group by 就神马都搞定了，比如对每组顾客购买的图书本书去重、求和。
SQL:

SELECT sum(TA.quantity) quantity ,
TB.book_type
FROM Table_A TA
OUTER JOIN Table_B TB
ON TA.book_id = TB.book_id
GROUP BY book_type

SELECT user_group, SUM(book_quantity) quantity, count(distinct book_id) sold_book
FROM my_datatable
GROUP BY user_group

那么相对应的，在R中，我们的解决策略是万能的data.table()。
R：

book_stat <- data.table(my_dataframe)[,list(quantity=sum(book_quantity), sold_book = length(unique(book_id))), by="user_group]

也不麻烦对嘛~可是，R里面还是有可以调用多种函数的优势哦。嘻嘻。

3. 表的连接和数据混合

咳咳，thanks to 著名的三大范式，SQL语句永远逃不掉各种各样的连接，内外左右，inner join, outer join, left join, right join 写来写去有没有！R里面呢，类似于SAS，有个神奇的merge()函数。每次看到讲left join 的教程示例的时候都觉得真心罗嗦难懂，相比而言R的merge()函数简洁明了了许多有木有！

依旧，假设我们第一个表，两个字段 book_id, book_quantity, 然后第二个表两个字段，book_id, book_type，包含的是书的分类信息。现在需要分类统计书的数量。

SQL:

这里用外链接，既如果图书在TB中没有分类信息，会自动归于NULL这一列。

用R呢，嘻嘻，很简单。

Book_stat <- merge(TableA, TableB, by="book_id", all.x=T, all.y=T)

这里其实可以简写all=TRUE (T 在R中等价于逻辑值TRUE），只是为了更清晰所以把x，y分开了。多明显啊，我就是要保留两个表中所有的观测对象，如果任意表缺失标记为NA即可。很简单的，merge()的参数和四大连接的关系就是：
INNER JOIN 等价于 merge(all=F)
LEFT JOIN 等价于 merge(all.x=T, all.y=F)
RIGHT JOIN 等价于 merge(all.x=F, all.y=T)
OUTER JOIN 等价于 merge(all=T)

嗯啊，反正对我来说，这个更好理解...

至于SQL的where和having条件，基本就是R中对于行的选择，不再赘述，参见新变量生成那里对于行的选择。TOP或者limit也可以通过head或者直接指定行序号n:m来搞定。其他的常见的就不多了吧...过去两周的时间，我基本就在用R的整理数据框架思路来实现SQL语句撰写的煎熬中度过，多少次烦的时候都想直接砸了显示器或者哀叹如果能导出到R里面该多好...磨合期啊。

注：我现在理解SQL架构还有一项主要的feature就是索引，哈希表是个很强大的东东。这东西某种程度上类似R中factor类型的数据，但是貌似水要深很多，为了提升性能值得继续好好研究。

注2：NOSQL架构拯救分析师啊

注3：数据整理绝对是最耗分析师时间的活，如果思路不清晰不知道想要进入分析模型的数据长什么样子，那就真的悲剧了，往往一天两天就是徒劳。这也是我的小册子新版第一章加的就是数据整理，血泪的教训啊。
另外一个耗时间的就是excel或者word中作图配文字，这个绝对需要knitr来拯救-亲，对于每个分类统计是很简单，但是对于每个分类都画图的话，您难道还准备告诉excel作循环？然后一张张复制粘贴到word里面？省省时间吧，knitr会save your life的，绝对是工欲善其事，必先利其器。分析不是也不应该是体力活哦。下周的上海R沙龙，一定要好好称赞一下knitr，相比于 reproducible research，它对于业界的意义就在于没有BI系统之前，自动写报告...轻量化高效工具！

注4：ipad果然不适合码代码...有typo或不满排版的，容我稍后电脑上修改。

注5：开始研究RHadoop，各种沦落伤不起啊。