朋友想借用我的银行账号把ebay上的钱转出来，要注意什么？# Money - 海外理财
g*4
1 楼
处理一个字符串，删除里面所有的A，double所有的B
例子，输入 CAABD, 输出是CBBD
要求in space , O (1), no extra memory cost,因为字符串处理变长的空间不算
例子，输入 CAABD, 输出是CBBD
要求in space , O (1), no extra memory cost,因为字符串处理变长的空间不算
s*r
2 楼
朋友在国内，在ebay和amazon上卖东西。前几天联系到我，说想叫我帮忙，他们在美国
的账号出了点问题，导致Ebay和amazon上的钱转不出来。现在想借用我的账号，把钱先
转到我账号里，然后再帮忙转回香港。
朋友还是比较值得信任的，倒不会有意骗我。但是把自己的私人账号这样借用，有什么
风险吗？会有什么需要注意的吗？
没有什么经验，所以还请大家多多指点。谢谢了。
的账号出了点问题，导致Ebay和amazon上的钱转不出来。现在想借用我的账号，把钱先
转到我账号里，然后再帮忙转回香港。
朋友还是比较值得信任的，倒不会有意骗我。但是把自己的私人账号这样借用，有什么
风险吗？会有什么需要注意的吗？
没有什么经验，所以还请大家多多指点。谢谢了。
f*t
3 楼
没有时间复杂度的要求？
n*9
4 楼
自己找麻烦，账号出麻烦让他联系客服
w*x
5 楼
第一趟从左到右去A数B,
第二趟从右到左double B
第二趟从右到左double B
c*7
6 楼
don't do it
【在 s******r 的大作中提到】
: 朋友在国内，在ebay和amazon上卖东西。前几天联系到我，说想叫我帮忙，他们在美国
: 的账号出了点问题，导致Ebay和amazon上的钱转不出来。现在想借用我的账号，把钱先
: 转到我账号里，然后再帮忙转回香港。
: 朋友还是比较值得信任的，倒不会有意骗我。但是把自己的私人账号这样借用，有什么
: 风险吗？会有什么需要注意的吗？
: 没有什么经验，所以还请大家多多指点。谢谢了。
【在 s******r 的大作中提到】
: 朋友在国内，在ebay和amazon上卖东西。前几天联系到我，说想叫我帮忙，他们在美国
: 的账号出了点问题，导致Ebay和amazon上的钱转不出来。现在想借用我的账号，把钱先
: 转到我账号里，然后再帮忙转回香港。
: 朋友还是比较值得信任的，倒不会有意骗我。但是把自己的私人账号这样借用，有什么
: 风险吗？会有什么需要注意的吗？
: 没有什么经验，所以还请大家多多指点。谢谢了。
g*4
7 楼
不是说了么 O(1)，再直白点就是两遍扫描了
【在 f*******t 的大作中提到】
: 没有时间复杂度的要求？
s*g
8 楼
借账号这种事情除非是亲爹亲妈否则别做
l*8
9 楼
bool Convert(char * buf, int bufSize)
{
int length = strlen(buf);
int newLength = length;
for (int i=0; i
newLength--;
else if(buf[i] == 'B')
newLength++;
if (newLength > bufSize - 1) return false;
int w = newLength-1;
for (int r = length-1; r>=0; r--) {
if(buf[r] != 'A')
buf[w--] = buf[r];
if (buf[r] == 'B')
buf[w--] = buf[r];
}
buf[newLength] = '\0';
return true;
}
{
int length = strlen(buf);
int newLength = length;
for (int i=0; i
newLength--;
else if(buf[i] == 'B')
newLength++;
if (newLength > bufSize - 1) return false;
int w = newLength-1;
for (int r = length-1; r>=0; r--) {
if(buf[r] != 'A')
buf[w--] = buf[r];
if (buf[r] == 'B')
buf[w--] = buf[r];
}
buf[newLength] = '\0';
return true;
}
i*g
10 楼
这个即使没风险 会不会也要交税？
g*4
11 楼
这里面有一个假设的，就是这个char*指向的位置有足够的内存空间可用
不能因为处理后字符串超过原来长度就返回错误
【在 l*********8 的大作中提到】
: bool Convert(char * buf, int bufSize)
: {
: int length = strlen(buf);
: int newLength = length;
: for (int i=0; i
: newLength--;
: else if(buf[i] == 'B')
: newLength++;
: if (newLength > bufSize - 1) return false;
不能因为处理后字符串超过原来长度就返回错误
【在 l*********8 的大作中提到】
: bool Convert(char * buf, int bufSize)
: {
: int length = strlen(buf);
: int newLength = length;
: for (int i=0; i
: newLength--;
: else if(buf[i] == 'B')
: newLength++;
: if (newLength > bufSize - 1) return false;
t*d
12 楼
对你来说最安全的办法是他paypal给你，你再paypal给他的了另一个帐号。
如果直接转到你的银行帐号，万一那部分钱有问题，以后可能从你的银行帐号里扣掉，
你就亏了。
如果直接转到你的银行帐号，万一那部分钱有问题，以后可能从你的银行帐号里扣掉，
你就亏了。
l*8
13 楼
Here bufLength is the length of the 内存空间, not the string.
【在 g*******4 的大作中提到】
: 这里面有一个假设的，就是这个char*指向的位置有足够的内存空间可用
: 不能因为处理后字符串超过原来长度就返回错误
【在 g*******4 的大作中提到】
: 这里面有一个假设的，就是这个char*指向的位置有足够的内存空间可用
: 不能因为处理后字符串超过原来长度就返回错误
d*a
14 楼
朋友肯定答应给％多少的好处。。。。
【在 s**********g 的大作中提到】
: 借账号这种事情除非是亲爹亲妈否则别做
【在 s**********g 的大作中提到】
: 借账号这种事情除非是亲爹亲妈否则别做
l*8
15 楼
Let me call it bufSize then :-)
【在 l*********8 的大作中提到】
: Here bufLength is the length of the 内存空间, not the string.
【在 l*********8 的大作中提到】
: Here bufLength is the length of the 内存空间, not the string.
I*l
16 楼
I am confused here: it seems you may erase some of the original characters
in the string. For example, if newLength < length, then starting from the
end, you will overwrite the characters that have not been processed.
【在 l*********8 的大作中提到】
: bool Convert(char * buf, int bufSize)
: {
: int length = strlen(buf);
: int newLength = length;
: for (int i=0; i
: newLength--;
: else if(buf[i] == 'B')
: newLength++;
: if (newLength > bufSize - 1) return false;
in the string. For example, if newLength < length, then starting from the
end, you will overwrite the characters that have not been processed.
【在 l*********8 的大作中提到】
: bool Convert(char * buf, int bufSize)
: {
: int length = strlen(buf);
: int newLength = length;
: for (int i=0; i
: newLength--;
: else if(buf[i] == 'B')
: newLength++;
: if (newLength > bufSize - 1) return false;
l*8
17 楼
good catch! thanks!
【在 I*******l 的大作中提到】
: I am confused here: it seems you may erase some of the original characters
: in the string. For example, if newLength < length, then starting from the
: end, you will overwrite the characters that have not been processed.
【在 I*******l 的大作中提到】
: I am confused here: it seems you may erase some of the original characters
: in the string. For example, if newLength < length, then starting from the
: end, you will overwrite the characters that have not been processed.
m*a
18 楼
有bug吧？如果newlength < length，你中间把原值覆盖了。前面一位说的先去A，再添
B应该是正确解法吧。
【在 l*********8 的大作中提到】
: bool Convert(char * buf, int bufSize)
: {
: int length = strlen(buf);
: int newLength = length;
: for (int i=0; i
: newLength--;
: else if(buf[i] == 'B')
: newLength++;
: if (newLength > bufSize - 1) return false;
B应该是正确解法吧。
【在 l*********8 的大作中提到】
: bool Convert(char * buf, int bufSize)
: {
: int length = strlen(buf);
: int newLength = length;
: for (int i=0; i
: newLength--;
: else if(buf[i] == 'B')
: newLength++;
: if (newLength > bufSize - 1) return false;
l*8
19 楼
yes, InnerCool also pointed it out. thanks
【在 m********a 的大作中提到】
: 有bug吧？如果newlength < length，你中间把原值覆盖了。前面一位说的先去A，再添
: B应该是正确解法吧。
【在 m********a 的大作中提到】
: 有bug吧？如果newlength < length，你中间把原值覆盖了。前面一位说的先去A，再添
: B应该是正确解法吧。
A*H
20 楼
how to remove A inplace at first step?
【在 m********a 的大作中提到】
: 有bug吧？如果newlength < length，你中间把原值覆盖了。前面一位说的先去A，再添
: B应该是正确解法吧。
【在 m********a 的大作中提到】
: 有bug吧？如果newlength < length，你中间把原值覆盖了。前面一位说的先去A，再添
: B应该是正确解法吧。
c*p
21 楼
把字符串从后往前移
【在 A*H 的大作中提到】
: how to remove A inplace at first step?
【在 A*H 的大作中提到】
: how to remove A inplace at first step?
b*u
22 楼
这是O(n)..
【在 g*******4 的大作中提到】
: 这里面有一个假设的，就是这个char*指向的位置有足够的内存空间可用
: 不能因为处理后字符串超过原来长度就返回错误
【在 g*******4 的大作中提到】
: 这里面有一个假设的，就是这个char*指向的位置有足够的内存空间可用
: 不能因为处理后字符串超过原来长度就返回错误
c*p
23 楼
他说的是O1 space吧
【在 b***u 的大作中提到】
: 这是O(n)..
【在 b***u 的大作中提到】
: 这是O(n)..
D*g
24 楼
我的code：
先扫一遍找到A的个数和B的个数
然后再扫一遍处理A
再扫一遍处理B
code里处理A和B的算法不太一样，第二种更好一点。另外，有没有包子？
/*input is assumed to end at '\0' and input is assumed to be long enough to
hold the
* transformed string
* */
static char[] deleteADoubleB(final char[] input) {
if (input == null || input.length == 0) {
return input;
}
int aCount = 0, bCount = 0, originalLen = 0;
for (int i = 0; i < input.length; ++i) {
if (input[i] == 'A') {
aCount ++;
}
if (input[i] == 'B') {
bCount ++;
}
if (input[i] == '\0') {
originalLen = i;
break;
}
}
int offSet = 0;
int idx = 0;
while (offSet <= aCount) {
while (idx < originalLen && input[idx] != 'A' ) {
if (offSet > 0) {
input[idx - offSet] = input[idx];
}
idx ++;
}
if (idx == originalLen) {
break;
}
offSet ++;
idx ++;
}
int newEnd0 = originalLen - aCount - 1;
int newEnd1 = originalLen + bCount - aCount - 1;
while (newEnd0 >= 0) {
if (input[newEnd0] != 'B') {
input[newEnd1] = input[newEnd0];
newEnd1 --; newEnd0 --;
} else {
input[newEnd1] = 'B';
newEnd1 --;
input[newEnd1] = 'B';
newEnd1 --; newEnd0 --;
}
}
return input;
}
static void testDeleteADoubleB() {
char[] input = new char[] {};
System.out.println(Arrays.toString(deleteADoubleB(input)));
input = new char[] {'C','D','E', '\0'};
System.out.println(Arrays.toString(deleteADoubleB(input)));
input = new char[] {'A','D','B', '\0'};
System.out.println(Arrays.toString(deleteADoubleB(input)));
input = new char[] {'B', 'C', 'A','D','B','\0','\0'};
System.out.println(Arrays.toString(deleteADoubleB(input)));
}
【在 w****x 的大作中提到】
: 第一趟从左到右去A数B,
: 第二趟从右到左double B
先扫一遍找到A的个数和B的个数
然后再扫一遍处理A
再扫一遍处理B
code里处理A和B的算法不太一样，第二种更好一点。另外，有没有包子？
/*input is assumed to end at '\0' and input is assumed to be long enough to
hold the
* transformed string
* */
static char[] deleteADoubleB(final char[] input) {
if (input == null || input.length == 0) {
return input;
}
int aCount = 0, bCount = 0, originalLen = 0;
for (int i = 0; i < input.length; ++i) {
if (input[i] == 'A') {
aCount ++;
}
if (input[i] == 'B') {
bCount ++;
}
if (input[i] == '\0') {
originalLen = i;
break;
}
}
int offSet = 0;
int idx = 0;
while (offSet <= aCount) {
while (idx < originalLen && input[idx] != 'A' ) {
if (offSet > 0) {
input[idx - offSet] = input[idx];
}
idx ++;
}
if (idx == originalLen) {
break;
}
offSet ++;
idx ++;
}
int newEnd0 = originalLen - aCount - 1;
int newEnd1 = originalLen + bCount - aCount - 1;
while (newEnd0 >= 0) {
if (input[newEnd0] != 'B') {
input[newEnd1] = input[newEnd0];
newEnd1 --; newEnd0 --;
} else {
input[newEnd1] = 'B';
newEnd1 --;
input[newEnd1] = 'B';
newEnd1 --; newEnd0 --;
}
}
return input;
}
static void testDeleteADoubleB() {
char[] input = new char[] {};
System.out.println(Arrays.toString(deleteADoubleB(input)));
input = new char[] {'C','D','E', '\0'};
System.out.println(Arrays.toString(deleteADoubleB(input)));
input = new char[] {'A','D','B', '\0'};
System.out.println(Arrays.toString(deleteADoubleB(input)));
input = new char[] {'B', 'C', 'A','D','B','\0','\0'};
System.out.println(Arrays.toString(deleteADoubleB(input)));
}
【在 w****x 的大作中提到】
: 第一趟从左到右去A数B,
: 第二趟从右到左double B
K*i
25 楼
是那个把空格变为%20的题的变体么？
r*t
26 楼
可不可以这样呢:
suppose 字符串长=n
1.在该字符串后面append原字符串 （得到2n 串）
2.j=0; i=n To 2n-1
对于追加字符串（n To 2n-1）:
if 'A', j 不变
if ‘B’， 位置j,j+1填‘B’， j=j+2
if 其他字符：位置j,填其他字符， j=j+1
3. 位置j 填‘\0’
【在 g*******4 的大作中提到】
: 处理一个字符串，删除里面所有的A，double所有的B
: 例子，输入 CAABD, 输出是CBBD
: 要求in space , O (1), no extra memory cost,因为字符串处理变长的空间不算
suppose 字符串长=n
1.在该字符串后面append原字符串 （得到2n 串）
2.j=0; i=n To 2n-1
对于追加字符串（n To 2n-1）:
if 'A', j 不变
if ‘B’， 位置j,j+1填‘B’， j=j+2
if 其他字符：位置j,填其他字符， j=j+1
3. 位置j 填‘\0’
【在 g*******4 的大作中提到】
: 处理一个字符串，删除里面所有的A，double所有的B
: 例子，输入 CAABD, 输出是CBBD
: 要求in space , O (1), no extra memory cost,因为字符串处理变长的空间不算
s*o
27 楼
void
Process(string& s) {
int size = s.size();
int count = 0;
for (int i = 0; i < size; ++i) {
if (s[i] == 'A') {
s[i] = '\0';
for (int j = i; j < size - 1; ++j) {
s[j] = s[j+1];
}
--size;
--i;
} else if (s[i] == 'B') {
count++;
}
}
int end = size + count - 1;
s.resize(end+1);
for (int i = size - 1; i >= 0; --i) {
if (s[i] == 'B') {
s[end--] = 'B';
s[end--] = 'B';
} else {
s[end--] = s[i];
}
}
}
【在 g*******4 的大作中提到】
: 处理一个字符串，删除里面所有的A，double所有的B
: 例子，输入 CAABD, 输出是CBBD
: 要求in space , O (1), no extra memory cost,因为字符串处理变长的空间不算
Process(string& s) {
int size = s.size();
int count = 0;
for (int i = 0; i < size; ++i) {
if (s[i] == 'A') {
s[i] = '\0';
for (int j = i; j < size - 1; ++j) {
s[j] = s[j+1];
}
--size;
--i;
} else if (s[i] == 'B') {
count++;
}
}
int end = size + count - 1;
s.resize(end+1);
for (int i = size - 1; i >= 0; --i) {
if (s[i] == 'B') {
s[end--] = 'B';
s[end--] = 'B';
} else {
s[end--] = s[i];
}
}
}
【在 g*******4 的大作中提到】
: 处理一个字符串，删除里面所有的A，double所有的B
: 例子，输入 CAABD, 输出是CBBD
: 要求in space , O (1), no extra memory cost,因为字符串处理变长的空间不算
p*2
28 楼
从前往后再从后往前就可以了吧。
s*e
29 楼
要结合＂从左添＂和＂从右添＂，
比如一个CAABBBCAABAACB要分成三段
CAABB BCAAB AACB
CAABB 从左添：CBBBB
BCAAB 从右添：BBCBB
AACB 从左添：CBB
＂从左添＂的段都是A在B前，继续scan，直到AB的个数相同，即convert后长度不变。
比如一个CAABBBCAABAACB要分成三段
CAABB BCAAB AACB
CAABB 从左添：CBBBB
BCAAB 从右添：BBCBB
AACB 从左添：CBB
＂从左添＂的段都是A在B前，继续scan，直到AB的个数相同，即convert后长度不变。
m*o
30 楼
thanks!
【在 g*******4 的大作中提到】
: 处理一个字符串，删除里面所有的A，double所有的B
: 例子，输入 CAABD, 输出是CBBD
: 要求in space , O (1), no extra memory cost,因为字符串处理变长的空间不算
【在 g*******4 的大作中提到】
: 处理一个字符串，删除里面所有的A，double所有的B
: 例子，输入 CAABD, 输出是CBBD
: 要求in space , O (1), no extra memory cost,因为字符串处理变长的空间不算
t*t
31 楼
第一遍处理A, 同时数B
第二遍处理B
to
【在 D********g 的大作中提到】
: 我的code：
: 先扫一遍找到A的个数和B的个数
: 然后再扫一遍处理A
: 再扫一遍处理B
: code里处理A和B的算法不太一样，第二种更好一点。另外，有没有包子？
: /*input is assumed to end at '\0' and input is assumed to be long enough to
: hold the
: * transformed string
: * */
: static char[] deleteADoubleB(final char[] input) {
第二遍处理B
to
【在 D********g 的大作中提到】
: 我的code：
: 先扫一遍找到A的个数和B的个数
: 然后再扫一遍处理A
: 再扫一遍处理B
: code里处理A和B的算法不太一样，第二种更好一点。另外，有没有包子？
: /*input is assumed to end at '\0' and input is assumed to be long enough to
: hold the
: * transformed string
: * */
: static char[] deleteADoubleB(final char[] input) {
r*k
32 楼
void deleteADoubleB(char *str, int length)
{
if (str == NULL || length < 0) return;
int newLen = 0;
int bCount = 0;
for (int i = 0; i < str[i] !='\0'; i++)
{
if (str[i] != 'A')
{
str[newLen++] = str[i];
}
if (str[i] == 'B')
{
bCount++;
}
}
if (newLen + bCount > length) return;
int i = newLen - 1;
newLen += bCount;
str[newLen--] = '\0';
while (i>0)
{
str[newLen--] = str[i];
if (str[i] == 'B')
{
str[newLen--] = 'B';
}
i--;
}
}
{
if (str == NULL || length < 0) return;
int newLen = 0;
int bCount = 0;
for (int i = 0; i < str[i] !='\0'; i++)
{
if (str[i] != 'A')
{
str[newLen++] = str[i];
}
if (str[i] == 'B')
{
bCount++;
}
}
if (newLen + bCount > length) return;
int i = newLen - 1;
newLen += bCount;
str[newLen--] = '\0';
while (i>0)
{
str[newLen--] = str[i];
if (str[i] == 'B')
{
str[newLen--] = 'B';
}
i--;
}
}
s*e
33 楼
Test Case: ABCCCCCCCCCCCCCCC
nothing wrong, but there is unnecessary shift in your algorithm.
【在 r****k 的大作中提到】
: void deleteADoubleB(char *str, int length)
: {
: if (str == NULL || length < 0) return;
:
: int newLen = 0;
: int bCount = 0;
: for (int i = 0; i < str[i] !='\0'; i++)
: {
: if (str[i] != 'A')
: {
nothing wrong, but there is unnecessary shift in your algorithm.
【在 r****k 的大作中提到】
: void deleteADoubleB(char *str, int length)
: {
: if (str == NULL || length < 0) return;
:
: int newLen = 0;
: int bCount = 0;
: for (int i = 0; i < str[i] !='\0'; i++)
: {
: if (str[i] != 'A')
: {
t*h
34 楼
谢谢。
看来是把150题两道原题给揉在一起了。给一个string，删掉特定的字符。比如“I am
a student"删”aeiou".第二个，把一个string里所有的space替换成20%
【在 g*******4 的大作中提到】
: 处理一个字符串，删除里面所有的A，double所有的B
: 例子，输入 CAABD, 输出是CBBD
: 要求in space , O (1), no extra memory cost,因为字符串处理变长的空间不算
看来是把150题两道原题给揉在一起了。给一个string，删掉特定的字符。比如“I am
a student"删”aeiou".第二个，把一个string里所有的space替换成20%
【在 g*******4 的大作中提到】
: 处理一个字符串，删除里面所有的A，double所有的B
: 例子，输入 CAABD, 输出是CBBD
: 要求in space , O (1), no extra memory cost,因为字符串处理变长的空间不算
s*f
35 楼
i only have scan 2 times version.
1st scan for to delete A and count B.
2nd scan double b from the end that we calculated from 1st scan.
【在 g*******4 的大作中提到】
: 处理一个字符串，删除里面所有的A，double所有的B
: 例子，输入 CAABD, 输出是CBBD
: 要求in space , O (1), no extra memory cost,因为字符串处理变长的空间不算
1st scan for to delete A and count B.
2nd scan double b from the end that we calculated from 1st scan.
【在 g*******4 的大作中提到】
: 处理一个字符串，删除里面所有的A，double所有的B
: 例子，输入 CAABD, 输出是CBBD
: 要求in space , O (1), no extra memory cost,因为字符串处理变长的空间不算
o*o
36 楼
public class StringProcessor {
//return new length
//assume ary is large enough
public static int process(char[] ary, int length) {
int i=0, j=-1;
int countB = 0;
while(i < length) {
if(j == -1) {
if(ary[i] == 'A')
j = i;
} else {
if(ary[i] != 'A') {
ary[j] = ary[i];
j++;
}
}
if(ary[i] == 'B')
countB++;
i++;
}
//j == new length
if(countB > 0) {
int n = j + countB - 1;
i = j-1;
while(i >= 0) {
ary[n] = ary[i];
n--;
if(ary[i] == 'B') {
ary[n] = ary[i];
n--;
}
i--;
}
}
return j + countB;
}
}
【在 w****x 的大作中提到】
: 第一趟从左到右去A数B,
: 第二趟从右到左double B
//return new length
//assume ary is large enough
public static int process(char[] ary, int length) {
int i=0, j=-1;
int countB = 0;
while(i < length) {
if(j == -1) {
if(ary[i] == 'A')
j = i;
} else {
if(ary[i] != 'A') {
ary[j] = ary[i];
j++;
}
}
if(ary[i] == 'B')
countB++;
i++;
}
//j == new length
if(countB > 0) {
int n = j + countB - 1;
i = j-1;
while(i >= 0) {
ary[n] = ary[i];
n--;
if(ary[i] == 'B') {
ary[n] = ary[i];
n--;
}
i--;
}
}
return j + countB;
}
}
【在 w****x 的大作中提到】
: 第一趟从左到右去A数B,
: 第二趟从右到左double B
o*o
37 楼
改进一下
public class StringProcessor {
//return new length
//assume ary is large enough
public static int process(char[] ary, int length) {
int i=0, j=0;
int countB = 0;
while(i < length) {
char c = ary[i++];
if(c != 'A') ary[j++] = c;
if(c == 'B') countB++;
}
//j == new length
if(countB > 0) {
int n = j + countB - 1;
i = j - 1;
while(i >= 0) {
char c = ary[i--];
ary[n--] = c;
if(c == 'B') ary[n--] = c;
}
}
return j + countB;
}
【在 o****o 的大作中提到】
: public class StringProcessor {
: //return new length
: //assume ary is large enough
: public static int process(char[] ary, int length) {
: int i=0, j=-1;
: int countB = 0;
: while(i < length) {
: if(j == -1) {
: if(ary[i] == 'A')
: j = i;
public class StringProcessor {
//return new length
//assume ary is large enough
public static int process(char[] ary, int length) {
int i=0, j=0;
int countB = 0;
while(i < length) {
char c = ary[i++];
if(c != 'A') ary[j++] = c;
if(c == 'B') countB++;
}
//j == new length
if(countB > 0) {
int n = j + countB - 1;
i = j - 1;
while(i >= 0) {
char c = ary[i--];
ary[n--] = c;
if(c == 'B') ary[n--] = c;
}
}
return j + countB;
}
【在 o****o 的大作中提到】
: public class StringProcessor {
: //return new length
: //assume ary is large enough
: public static int process(char[] ary, int length) {
: int i=0, j=-1;
: int countB = 0;
: while(i < length) {
: if(j == -1) {
: if(ary[i] == 'A')
: j = i;
t*j
38 楼
nod，扫描两遍，第一遍数数计算 output string长度。
第二遍从后向前移动处理。
【在 c****p 的大作中提到】
: 把字符串从后往前移
第二遍从后向前移动处理。
【在 c****p 的大作中提到】
: 把字符串从后往前移
y*u
39 楼
这就不是O(1)了啊
【在 w****x 的大作中提到】
: 第一趟从左到右去A数B,
: 第二趟从右到左double B
【在 w****x 的大作中提到】
: 第一趟从左到右去A数B,
: 第二趟从右到左double B
m*y
40 楼
同意楼上peking2。从前往后，去A，从后往前，double B。
C代码如下：
#include
#define MAX_S_LENGTH 1024
void remove_a_double_b(char *s) {
int i, j, n, na, nb, nc; // nc is number of characters other than A
na = nb = 0;
j = 0;
for (i = 0; s[i] != '\0'; i++) {
if (s[i] == 'A')
na++;
else {
s[j] = s[i];
j++;
if (s[i] == 'B')
nb++;
}
}
n = i;
nc = j;
i = n - na + nb;
s[i] = '\0';
i--;
for (j = nc - 1; j >= 0; j--) {
if (s[j] == 'B') {
s[i] = 'B';
i--;
s[i] = 'B';
i--;
}
else {
s[i] = s[j];
i--;
}
}
}
void main()
{
char s[MAX_S_LENGTH];
scanf("%s", s);
remove_a_double_b(s);
printf("%s\n", s);
}
【在 p*****2 的大作中提到】
: 从前往后再从后往前就可以了吧。
C代码如下：
#include
#define MAX_S_LENGTH 1024
void remove_a_double_b(char *s) {
int i, j, n, na, nb, nc; // nc is number of characters other than A
na = nb = 0;
j = 0;
for (i = 0; s[i] != '\0'; i++) {
if (s[i] == 'A')
na++;
else {
s[j] = s[i];
j++;
if (s[i] == 'B')
nb++;
}
}
n = i;
nc = j;
i = n - na + nb;
s[i] = '\0';
i--;
for (j = nc - 1; j >= 0; j--) {
if (s[j] == 'B') {
s[i] = 'B';
i--;
s[i] = 'B';
i--;
}
else {
s[i] = s[j];
i--;
}
}
}
void main()
{
char s[MAX_S_LENGTH];
scanf("%s", s);
remove_a_double_b(s);
printf("%s\n", s);
}
【在 p*****2 的大作中提到】
: 从前往后再从后往前就可以了吧。
J*9
41 楼
char *hkStringRemoveADoubleB(char *str)
{
if (!str) return NULL;
char *s=str;
char *d=str;
int countb = 0;
int len=0;
while(*s)
{
if (*s=='B') countb++; /// Count B
if(*s!='A') /// Remove A
{
*d++=*s++;
len++;
}
else
s++;
}
if(len)
{
s = str+(len+countb); ///New string length
*s = '\0';
s--;
d--;
while(d!=str)
{
if (*d=='B')
*s-- = 'B';
*s--=*d--;
}
if (*d=='B') /// If the first one is B
*s = 'B';
}
return str;
}
Test cases:
str1=CAABD
str1=CBBD
str1=ACAABDB
str1=CBBDBB
str1=BACAABDBA
str1=BBCBBDBB
str1=ABCCCCCCCCCCCCCCC
str1=BBCCCCCCCCCCCCCCC
{
if (!str) return NULL;
char *s=str;
char *d=str;
int countb = 0;
int len=0;
while(*s)
{
if (*s=='B') countb++; /// Count B
if(*s!='A') /// Remove A
{
*d++=*s++;
len++;
}
else
s++;
}
if(len)
{
s = str+(len+countb); ///New string length
*s = '\0';
s--;
d--;
while(d!=str)
{
if (*d=='B')
*s-- = 'B';
*s--=*d--;
}
if (*d=='B') /// If the first one is B
*s = 'B';
}
return str;
}
Test cases:
str1=CAABD
str1=CBBD
str1=ACAABDB
str1=CBBDBB
str1=BACAABDBA
str1=BBCBBDBB
str1=ABCCCCCCCCCCCCCCC
str1=BBCCCCCCCCCCCCCCC
r*s
42 楼
Test case:
AAAAAAAAAAAAAAAAAAA
这样的输入怎么办
AAAAAAAAAAAAAAAAAAA
这样的输入怎么办
s*n
43 楼
Good thread
e*s
44 楼
弱问一句，如果JAVA怎么办？String是immutable,不可能in place。那用一个
StringBuilder直接见‘A'忽略，'B'写两次，其他照写。。。
是不是如果你说你写JAVA他就不考这题了？
StringBuilder直接见‘A'忽略，'B'写两次，其他照写。。。
是不是如果你说你写JAVA他就不考这题了？
f*l
45 楼
Java 可以认为传进来的是char［］，然后算法就基本一样了。当然，如果非要追根问
底的话String.toCharArray()其实已经make了一个new copy了。。。感觉类似这种题都
是在很早以前存储比较贵，容量比较小的时候make sense，目前基本都是空间换时间。
。。但是如果面试题的话，没办法，咱们是做题的，没法评判考卷，呵呵。有空贴个
Java代码上来。
底的话String.toCharArray()其实已经make了一个new copy了。。。感觉类似这种题都
是在很早以前存储比较贵，容量比较小的时候make sense，目前基本都是空间换时间。
。。但是如果面试题的话，没办法，咱们是做题的，没法评判考卷，呵呵。有空贴个
Java代码上来。
f*l
46 楼
Java version:
/*
* Process string, remove 'A' and double 'B'
*/
public static String processString(char[] array, int realLen) {
int newLen = realLen;
int pos = 0;
for (int i = 0; i < realLen; i++) {
char c = array[i];
if (c == 'A')
newLen--;
else {
if (c == 'B')
newLen++;
array[pos++] = array[i];
}
}
int j = newLen - 1;
for (int i = pos - 1; i >= 0; i--) {
if (array[i] == 'B') {
array[j--] = 'B';
}
array[j--] = array[i];
}
return new String(array, 0, newLen);
}
/*
* Process string, remove 'A' and double 'B'
*/
public static String processString(char[] array, int realLen) {
int newLen = realLen;
int pos = 0;
for (int i = 0; i < realLen; i++) {
char c = array[i];
if (c == 'A')
newLen--;
else {
if (c == 'B')
newLen++;
array[pos++] = array[i];
}
}
int j = newLen - 1;
for (int i = pos - 1; i >= 0; i--) {
if (array[i] == 'B') {
array[j--] = 'B';
}
array[j--] = array[i];
}
return new String(array, 0, newLen);
}
f*l
47 楼
Related test cases:
@Test
public void testProcessString() {
String s1 = "CAABD";
String target1 = "CBBD";
Assert.assertEquals(target1, StringAndArray.processString(s1.
toCharArray(), s1.length()));
String s2 = "ACAABDB";
String target2 = "CBBDBB";
Assert.assertEquals(target2, StringAndArray.processString(s2.
toCharArray(), s2.length()));
String s3 = "BACAABDBA";
String target3 = "BBCBBDBB";
Assert.assertEquals(target3, StringAndArray.processString(s3.
toCharArray(), s3.length()));
String s4 = "ABCCCCCCCCCCCCCCC";
String target4 = "BBCCCCCCCCCCCCCCC";
Assert.assertEquals(target4, StringAndArray.processString(s4.
toCharArray(), s4.length()));
String s5 = "BBC";
int len5 = s5.length();
s5 += " ";
String target5 = "BBBBC";
Assert.assertEquals(target5, StringAndArray.processString(s5.
toCharArray(), len5));
}
@Test
public void testProcessString() {
String s1 = "CAABD";
String target1 = "CBBD";
Assert.assertEquals(target1, StringAndArray.processString(s1.
toCharArray(), s1.length()));
String s2 = "ACAABDB";
String target2 = "CBBDBB";
Assert.assertEquals(target2, StringAndArray.processString(s2.
toCharArray(), s2.length()));
String s3 = "BACAABDBA";
String target3 = "BBCBBDBB";
Assert.assertEquals(target3, StringAndArray.processString(s3.
toCharArray(), s3.length()));
String s4 = "ABCCCCCCCCCCCCCCC";
String target4 = "BBCCCCCCCCCCCCCCC";
Assert.assertEquals(target4, StringAndArray.processString(s4.
toCharArray(), s4.length()));
String s5 = "BBC";
int len5 = s5.length();
s5 += " ";
String target5 = "BBBBC";
Assert.assertEquals(target5, StringAndArray.processString(s5.
toCharArray(), len5));
}
u*g
48 楼
我想他是O(n)的意思。。。不可能O(1)啊你至少要把输入过一边。。当然如果n代表的
是输入的整个string那是O(1)的……
【在 y**********u 的大作中提到】
: 这就不是O(1)了啊
是输入的整个string那是O(1)的……
【在 y**********u 的大作中提到】
: 这就不是O(1)了啊
相关阅读
小白求里程卡推荐freedom 怎么看加油站买的油卡算不算5%？AMEX Platinum明年还会有100k bonus的offer吗5000美元换人民币的问题问个从工行网上电汇到美国帐户的问题问一个愚蠢的问题， 信用卡公司寄的0%apr支票是干嘛的啊freedom 点数和 ink 点数 二手版为什么不同价?包子问题，spg转aa还有优惠吗真心请教，从国内借钱付首付的钱能回到fidelity的账户吗有了amex gold premier以后还能用credit match blue cash preferred的offer么？F1学生可以买股票之类的吗？30K TYP after Spending $3000 in the first 6 Months of Open开uhual把别人阳台装缺了一大块，能走uhual的保险吗？ (转载)chase freedom 副卡持有人可以将点数转到自己的chase saphire preferred上吗Amex BCP 的$250 offer 只有新用户才有吗？chase的freedom卡的点数不能转到美联航的里程吗？？？？？？aa statement后 多久看到bonus points??Amazon Payment 被 Citi AA 算成 Cash Advance 啦哭死了，grocery买不到大额visa/amexGCChase Freedom visa和mastercard能否同时拥有？