avatar
aababccbc remove abc# JobHunting - 待字闺中
z*c
1
版上清净不少,我趁机问个正事。
帮朋友弄startup,我主要负责很highlevel的系统设计,因为跟我自己做的方向还挺近
的。其他的比如找投资人和市场这些事情我参与的不多,说实话也没那么多功夫。但是
既然入伙了,还是想尽量多参与一些,只是不太好把握这个度。比如每周花半天搞搞?
当然了,是在不影响正常教学和我自己的项目的前提下。有没有前辈有过类似经验的?
朋友没的说,很实在的一哥们,我花多少时间他都会挺高兴的。
avatar
j*y
2
不能用java的function
aababccbc remove abc 最后应该""
有啥思路?多谢
avatar
b*1
3
学校每年还会问这个事情,好像不能超过多少时间。

【在 z**c 的大作中提到】
: 版上清净不少,我趁机问个正事。
: 帮朋友弄startup,我主要负责很highlevel的系统设计,因为跟我自己做的方向还挺近
: 的。其他的比如找投资人和市场这些事情我参与的不多,说实话也没那么多功夫。但是
: 既然入伙了,还是想尽量多参与一些,只是不太好把握这个度。比如每周花半天搞搞?
: 当然了,是在不影响正常教学和我自己的项目的前提下。有没有前辈有过类似经验的?
: 朋友没的说,很实在的一哥们,我花多少时间他都会挺高兴的。

avatar
k*7
4
用栈吧,从左到右逐符入栈,遇到c就查栈顶两个是不是ba,是就都pop了,然后继续把
下一个入栈
avatar
z*c
5
恩,跟学校我肯定就说挂个名,没花啥时间。

【在 b*********1 的大作中提到】
: 学校每年还会问这个事情,好像不能超过多少时间。
avatar
b*n
6
How to check the top 2 objects? It seem we can only look at the top
object.
Another question is we have to check N-1 chars from the top of the
stack, where N is the length of the str2. If there are multiple
characters in str2 that are the same as its last char (e.g. accccbc),
then even if str1 is the same as string 2, we have to do extra check 4
times whenever we meet a 'c' in str1.
My idea is to have a companion array recording the maximum matched index
of the char sequence in str1. If there is a total match of str2, remove
it, continue with the next character. Since we recorded the max matched
index of previous char sequence in str1, we can continue the matching
and so on so forth. If there is a mismatch of current character, reset
the array because there won't be any matching of all the previous char
sequence with this mismatched char.
Below is the code. For convenience, used a stack to hold the char seq,
and the output is in reverse order. But the main idea is presented.
#include
#include
#include
using namespace std;
int main()
{
string str1, str2;
cout << "Enter string 1:";
getline(cin, str1);
cout << "Enter string 2:";
getline(cin, str2);
int len1=str1.length();
int len2=str2.length();
// str1 is empty.
if(len1==0) return 0;
//str2 is empty or str1 is shorter than str2.
if((len2==0)||(len1
int *pMatchArray=new int[len1/len2];
for (int i = 0; i*(pMatchArray+i) = -1;
int last = 0; // last active item in array, record matching of
current char sequence
int j=0; // index used in str2
stack schar;
for(int i=0; i{
schar.push(str1[i]);
if(str1[i] == str2[j])
{
(*(pMatchArray+last))++;
if((++j)==len2) //match found for whole str2
{
//remove str2 from current pos;
for(int itmp=0; itmpschar.pop();
*(pMatchArray+last) = -1;
if (last == 0)
j=0;
else
{
j = *(pMatchArray+(--last));
j++;
}
}
}
else if(str1[i] == str2[0])
{
last++;
*(pMatchArray+last) = 0;
j=1;
}
else
{
while(last>=0)
*(pMatchArray+(last--)) = 0;
last = 0;
j = 0;
}
}
while(!schar.empty())
{
cout << schar.top();
schar.pop();
}
return 0;
}
avatar
b*n
7
我们这里consulting不能超过每周一天。
avatar
h*d
8
楼主的题目貌似不是删除连续substring把,不过那貌似更简单些
avatar
O*r
9
我们也是,一周一天不为过,但要report。你去查一查你们学校的bylaw。
avatar
m*q
10
这个题目是删除所有a,b,c的occurrence么?
还是只删除按顺序出现的abc?
前者的话,两个指针,做in-place deletion就行了,O(n)

【在 j**y 的大作中提到】
: 不能用java的function
: aababccbc remove abc 最后应该""
: 有啥思路?多谢

avatar
z*c
11
原贴没写清楚,来改改。
跟学校我肯定就说挂个名,全心全意为学校服务。公司那边,我不拿工资不走账;我有
的只是一些原始股,除了co-founder没有其他职务。所以理论上,我是不是可以自由分
配花多少时间在公司上?(比如我把bbs灌水的时间用在了跟哥们讨论项目上了)
avatar
l*g
12
他的意思应该是recursively删除出现的abc, 到最后不出现abc为止
你说得对,这题用两个指针in-place做就可以了,不需要用额外的stack或者array
不过对lz的原题,O(n)是不够的。假如要删除的pattern的长度是m, worst case,譬如
acccccccc, 需要O(m*n);不过,如果m长度固定或很小,可以认为是 O(n)

【在 m**q 的大作中提到】
: 这个题目是删除所有a,b,c的occurrence么?
: 还是只删除按顺序出现的abc?
: 前者的话,两个指针,做in-place deletion就行了,O(n)

avatar
s*e
13
我有些经验。如果真要想做好,还是得投入不少时间的。每周半天,恐怕只能做点框架
性的东西,细节比较难做。
当然也可能是我自己效率太低。

【在 z**c 的大作中提到】
: 版上清净不少,我趁机问个正事。
: 帮朋友弄startup,我主要负责很highlevel的系统设计,因为跟我自己做的方向还挺近
: 的。其他的比如找投资人和市场这些事情我参与的不多,说实话也没那么多功夫。但是
: 既然入伙了,还是想尽量多参与一些,只是不太好把握这个度。比如每周花半天搞搞?
: 当然了,是在不影响正常教学和我自己的项目的前提下。有没有前辈有过类似经验的?
: 朋友没的说,很实在的一哥们,我花多少时间他都会挺高兴的。

avatar
l*g
14
用C++写了一个版本:
void RecursivelyRemoveSubString(char *str, const char *sub)
{
if (!str || !sub || *sub == 0 || *str == 0 || strlen(str) < strlen(sub))
return;
char *end = str;
char *cur = str;
int subLen = strlen(sub);
char subEnd = sub[subLen - 1];

while (*cur != 0)
{
*end = *cur;
if (*end == subEnd)
{
char *reCur = end;
int subIndex = subLen - 1;
bool match = true;
bool reCurEnd = false;
while (!reCurEnd && subIndex >= 0)
{
if (reCur == str)
reCurEnd = true;
if (*reCur == sub[subIndex])
{
reCur--;
subIndex--;
}
else
{
match = false;
break;
}
}
if (match && subIndex < 0)
end = reCur;
}
cur++; end++;
}
*end = 0;
}

【在 l*****g 的大作中提到】
: 他的意思应该是recursively删除出现的abc, 到最后不出现abc为止
: 你说得对,这题用两个指针in-place做就可以了,不需要用额外的stack或者array
: 不过对lz的原题,O(n)是不够的。假如要删除的pattern的长度是m, worst case,譬如
: acccccccc, 需要O(m*n);不过,如果m长度固定或很小,可以认为是 O(n)

avatar
n*n
15
自己在公司的地位取决于自己的付出,所以这个其实是自己可以选择的。如果是
每周半天的话,那你将来在公司的地位估计就是个顾问型的cofounder,也还不
错。不过,从俺的经验来看,公司没赚大钱的时候,大家都客客气气地,一旦公
司小有成绩,那么顾问型的cofounder一般会被边缘化。

【在 z**c 的大作中提到】
: 原贴没写清楚,来改改。
: 跟学校我肯定就说挂个名,全心全意为学校服务。公司那边,我不拿工资不走账;我有
: 的只是一些原始股,除了co-founder没有其他职务。所以理论上,我是不是可以自由分
: 配花多少时间在公司上?(比如我把bbs灌水的时间用在了跟哥们讨论项目上了)

avatar
g*s
16
Even if m is not very small, there is O(n) algorithm.

【在 l*****g 的大作中提到】
: 他的意思应该是recursively删除出现的abc, 到最后不出现abc为止
: 你说得对,这题用两个指针in-place做就可以了,不需要用额外的stack或者array
: 不过对lz的原题,O(n)是不够的。假如要删除的pattern的长度是m, worst case,譬如
: acccccccc, 需要O(m*n);不过,如果m长度固定或很小,可以认为是 O(n)

avatar
z*c
17
多谢分享

★ 发自iPhone App: ChineseWeb 13

【在 s**********e 的大作中提到】
: 我有些经验。如果真要想做好,还是得投入不少时间的。每周半天,恐怕只能做点框架
: 性的东西,细节比较难做。
: 当然也可能是我自己效率太低。

avatar
l*g
18
你是对的
如果m是变量,那O(mn)就不能简化成O(n)

【在 g***s 的大作中提到】
: Even if m is not very small, there is O(n) algorithm.
avatar
z*c
19
醍醐灌顶

★ 发自iPhone App: ChineseWeb 13

【在 n*****n 的大作中提到】
: 自己在公司的地位取决于自己的付出,所以这个其实是自己可以选择的。如果是
: 每周半天的话,那你将来在公司的地位估计就是个顾问型的cofounder,也还不
: 错。不过,从俺的经验来看,公司没赚大钱的时候,大家都客客气气地,一旦公
: 司小有成绩,那么顾问型的cofounder一般会被边缘化。

avatar
g*s
20
I meant, there is a algorithm in O(n) instead of O(m*n).

【在 l*****g 的大作中提到】
: 你是对的
: 如果m是变量,那O(mn)就不能简化成O(n)

avatar
C*X
21
你是有风险的。good luck ...

【在 z**c 的大作中提到】
: 醍醐灌顶
:
: ★ 发自iPhone App: ChineseWeb 13

avatar
l*g
22
请zkss, 先谢过

【在 g***s 的大作中提到】
: I meant, there is a algorithm in O(n) instead of O(m*n).
avatar
z*c
23
谢谢提醒。比如公司负债?我记得是无本买卖,烧的全是投资人的钱。

★ 发自iPhone App: ChineseWeb 13

【在 C*********X 的大作中提到】
: 你是有风险的。good luck ...
avatar
h*d
24
请问in-place怎么O(n)?不是O(m*n)?

两个指针,做in-place deletion就行了,O(n)

【在 m**q 的大作中提到】
: 这个题目是删除所有a,b,c的occurrence么?
: 还是只删除按顺序出现的abc?
: 前者的话,两个指针,做in-place deletion就行了,O(n)

avatar
t*s
25
如果能用O(n)空间的话似乎确实可以用O(n)时间完成。
顺序读取的过程中遇到匹配串就开始顺序编号,比如
abababccccccc
编号为
1212123333333
一旦读到匹配串的终结字符就检查上一个编号是不是m-1
如果是就删除当前字符和之前m-1个字符。
avatar
t*s
26

漏说了,非顺序出现的匹配串字符或者不匹配字符一律编为0

【在 t*****s 的大作中提到】
: 如果能用O(n)空间的话似乎确实可以用O(n)时间完成。
: 顺序读取的过程中遇到匹配串就开始顺序编号,比如
: abababccccccc
: 编号为
: 1212123333333
: 一旦读到匹配串的终结字符就检查上一个编号是不是m-1
: 如果是就删除当前字符和之前m-1个字符。

avatar
t*s
27
嗯,这个不对,见笑了,大家继续

【在 t*****s 的大作中提到】
:
: 漏说了,非顺序出现的匹配串字符或者不匹配字符一律编为0

avatar
g*s
28
you assumed there are no duplicate chars in the sub string.
If so, your algo can just be changed a little to make it work. Also, no need extra space.

【在 t*****s 的大作中提到】
: 如果能用O(n)空间的话似乎确实可以用O(n)时间完成。
: 顺序读取的过程中遇到匹配串就开始顺序编号,比如
: abababccccccc
: 编号为
: 1212123333333
: 一旦读到匹配串的终结字符就检查上一个编号是不是m-1
: 如果是就删除当前字符和之前m-1个字符。

avatar
t*s
29
删除后将编号状态机set到剩余的前一个字符的状态,即如果前一个字符是a,那么下一
个读取字符如果
是b就编号为2而非0。
这样应该可以。

【在 t*****s 的大作中提到】
: 嗯,这个不对,见笑了,大家继续
avatar
t*s
30
确实没考虑连续重复字符的情况。KMP的具体算法记不清了,还得回去好好复习去。

need extra space.

【在 g***s 的大作中提到】
: you assumed there are no duplicate chars in the sub string.
: If so, your algo can just be changed a little to make it work. Also, no need extra space.

avatar
g*s
31
Based on KMP

请zkss, 先谢过
★ Sent from iPhone App: iReader Mitbbs 6.81 - iPhone Lite

【在 l*****g 的大作中提到】
: 请zkss, 先谢过
avatar
t*s
32
拿一个栈把所有的match break点压栈,匹配-删除到最后了再一个一个读回来重新比较?

【在 g***s 的大作中提到】
: Based on KMP
:
: 请zkss, 先谢过
: ★ Sent from iPhone App: iReader Mitbbs 6.81 - iPhone Lite

avatar
l*g
33
KMP是用于找出所有matches in one traveral of the string
譬如,从 abcdabcaabcbc 里找abc, 用 KMP 就可以找出 3 matches
LZ的问题是:找出match, 删除,再在结果里找match, 再删除,直到结果里无match为止
过程如下:
input: abcdabcaabcbc
find matches: [abc]d[abc]a[abc]bc
delete matches: dabc
find matches again: d[abc]
delete matches: d
no more match
output: d
这儿recursively地做了两次find-->delete;如果把KMP用于每一次recursion, 单个
recursion的复杂度是 O(n), 但多个recursion的总的复杂度还是会累加

【在 g***s 的大作中提到】
: Based on KMP
:
: 请zkss, 先谢过
: ★ Sent from iPhone App: iReader Mitbbs 6.81 - iPhone Lite

avatar
g*e
34
this is O(nm)

较?

【在 t*****s 的大作中提到】
: 拿一个栈把所有的match break点压栈,匹配-删除到最后了再一个一个读回来重新比较?
avatar
g*e
35
不需要recursive,只需要根据automata回到上一个position,每个元素最多访问两次
,所以是O(n)
我想grass应该是这个意思

为止

【在 l*****g 的大作中提到】
: KMP是用于找出所有matches in one traveral of the string
: 譬如,从 abcdabcaabcbc 里找abc, 用 KMP 就可以找出 3 matches
: LZ的问题是:找出match, 删除,再在结果里找match, 再删除,直到结果里无match为止
: 过程如下:
: input: abcdabcaabcbc
: find matches: [abc]d[abc]a[abc]bc
: delete matches: dabc
: find matches again: d[abc]
: delete matches: d
: no more match

avatar
g*s
36
删除以后,回到当前位置-m。重新计算这m个元素的跳转位置 O(m)
那么每次删除m个元素,我们需要额外的O(m)时间。
最多可以删除n个元素,所以最多额外用O(n)的时间。

【在 g**e 的大作中提到】
: 不需要recursive,只需要根据automata回到上一个position,每个元素最多访问两次
: ,所以是O(n)
: 我想grass应该是这个意思
:
: 为止

avatar
c*t
37
能不能解释一下什么是in-place deletion?
能给个一般的例子吗?不一定要用lz的题目为例。
谢谢!

【在 m**q 的大作中提到】
: 这个题目是删除所有a,b,c的occurrence么?
: 还是只删除按顺序出现的abc?
: 前者的话,两个指针,做in-place deletion就行了,O(n)

avatar
g*e
38
O(n) time, O(1) space based on KMP. Here I used an utility ArrayList but it
can be removed to do in-place.
public static void recursiveDelete(String target, String pattern) {
if (target == null || pattern == null || pattern.length() ==
0
|| target.length() == 0)
return;
// convert target string into a ArrayList of char
ArrayList charset = new ArrayList();
for (char c : target.toCharArray()) {
charset.add(c);
}

printArray(charset);
// get KMP automata for pattern
int[] overlap = getOverlap(pattern);

int i = 0, j = 0;
while (iwhile(true) {

if (i>=0 && j>=0 && charset.get(i) ==
pattern.charAt(j)) {
j++;

if (j == pattern.length()) {
System.out.print(" -> ");

//delete pattern from target
while(j>0) {
charset.remove(i--);
j--;
}
printArray(charset);

//j = 0; //reset j; this is
unnecessary as j=0 after the loop
i -= pattern.length(); //
retrogress m positions
}
break;

} else if (j == 0){
break;
} else
j = overlap[j];
}

i++;
}
}

private static void printArray(List ca) {
for (char c : ca) {
System.out.print(c);
}
}
/**
* build automata for pattern p based on KMP, O(n)
*/
private static int[] getOverlap(String p) {
if (p.length() == 0)
return null;
int[] o = new int[p.length()];
o[0] = -1;
for (int i = 1; i < p.length(); i++) {
o[i] = o[i - 1] + 1;
while (o[i] > 0 && p.charAt(i-1) != p.charAt(o[i] -
1))
o[i] = o[o[i] - 1] + 1;
}
o[0] = 0;
return o;
}

两次

【在 g***s 的大作中提到】
: 删除以后,回到当前位置-m。重新计算这m个元素的跳转位置 O(m)
: 那么每次删除m个元素,我们需要额外的O(m)时间。
: 最多可以删除n个元素,所以最多额外用O(n)的时间。

avatar
l*g
39
别计较maxq说的 in-place deletion, 不是什么正规定义
他意思应该是指 in-place algorithm
因为这个algorithm 用于做 deletion, 所以随口说了 in-place deletion

【在 c*********t 的大作中提到】
: 能不能解释一下什么是in-place deletion?
: 能给个一般的例子吗?不一定要用lz的题目为例。
: 谢谢!

avatar
c*t
40
到底这个题目问的是哪种情形:
1. 是删除单个的 a, b, c吗?
还是
2. 删除连续出现的‘abc’?
谢谢!

【在 j**y 的大作中提到】
: 不能用java的function
: aababccbc remove abc 最后应该""
: 有啥思路?多谢

avatar
s*n
41
二楼的说的很好啊。用stack
string removeSubstringRecursively(string s, string matchString){
struct stackElement{
char s,
int index,
}
Stack stack= new Stack();
int index = 0;
foreach (char c in s) {
if (matchString[index] == c){
stack.push(c,index++);
if (index == matchString.Length){
for( int i = 0; i < index ; i++)
stack.Pop();
index = stack.peek().index;
}
}
else{
index = (c = matchstring[0] ? 0, -1);
stack.push(c, index);
}
}

StringBuilder sb = new StringBuilder (stack.Count);
for( int i = 0; i < stack.Count; i++){
sb.append(stack.pop().s);
}
return sb.Reverse();
}
avatar
s*y
42
不用栈应该也可以吧
bool isMatch(const std::string &str,const std::string &pattern,int loc){
int i = pattern.size()-1;
while( i >= 0){
if(pattern[i--] != str[loc--])
return false;
}
return true;
}
void removeStringPattern(std::string &str, const std::string & pattern){
if( str.empty() || pattern.empty() || str.size() < pattern.size())
return;
int patternSize = pattern.size();
int strSize = str.size();
int loc = 0;
while(strSize >= patternSize && loc < strSize){
if(pattern[patternSize-1]==str[loc] && isMatch(str,pattern,loc)){
str.erase(loc-patternSize+1, patternSize);
loc -= patternSize -1;
strSize -= patternSize;
}
else
loc++;
}
}
相关阅读
logo
联系我们隐私协议©2024 redian.news
Redian新闻
Redian.news刊载任何文章,不代表同意其说法或描述,仅为提供更多信息,也不构成任何建议。文章信息的合法性及真实性由其作者负责,与Redian.news及其运营公司无关。欢迎投稿,如发现稿件侵权,或作者不愿在本网发表文章,请版权拥有者通知本网处理。