To reverse a string

[sudharsan]

could any one please give me a code to reverse a string of more than
1MB .???
Thanks in advance

[santosh]

Richard G. Riley wrote:

On 2006-03-20, santosh <sa*********@gm ail.com> wrote:

sudharsan wrote:

could any one please give me a code to reverse a string of more than
1MB .???
Thanks in advance

Here's one way of doing it.
NOTE: If your implementation already defines a strrev() function, then
rename the corresponding function in the following code to avoid linker
errors.

#include <stddef.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

bool strrev( char *s ) {
char tmp, *adv_p = NULL, *reg_p = NULL;
size_t l = 0;
ptrdiff_t seperation = 0;

if(s == NULL || (l = strlen(s)) < 2)
return false;

It's legal to reverse a string of one character. Or does "false" just
indicate no reversal was necessary?

Sinan pointed it out earlier. I should've decoupled the tests and
returned true for the case you suggest.

else {

Its all an else in this case since you returned.

I'm sorry, I don't get what you're trying to say here.

adv_p = s;
--l;
reg_p = adv_p + l;
}

do {
tmp = *adv_p;
*adv_p = *reg_p;
*reg_p = tmp;
++adv_p;
--reg_p;
seperation = reg_p - adv_p;
} while(seperatio n > 0);

return true;
}

nicer just to use the strlen/2 IMO.

void reverse(char * refS){
/* assume parent does parameter checks */
unsigned int len = (unsigned int)strlen(refS );
char * refE=refS+len-1; /* if len is 0 no problem since nothing done*/
len=len/2; /* or len>>=1 */
while(len--){
char c = *refS; /* front char */
*refS++ = *refE; /* is now end char */
*refE-- = c; /* end char now start char */
}
}

Your version is more concise. But why not use the proper type for
strlen()'s return value? What's the reason to cast it to an unsigned
int?

Thanks for the feedback.

[Richard G. Riley]

On 2006-03-20, A. Sinan Unur <1u**@llenroc.u de.invalid> wrote:

"Richard G. Riley" <rg****@gmail.c om> wrote in news:tub3f3-03i.ln1
@fujitsu.mydoma in.com:

void reverse(char * refS){
/* assume parent does parameter checks */
unsigned int len = (unsigned int)strlen(refS );

size_t len = strlen(refS);

Sinan

I like using unsigned ints when I use bit shifts :
although I suppose I could cast it at that point so, yes, size_t is
better. But is it wrong to cast the return from strlen? What does
size_t "equate" to in the standard?

[Richard G. Riley]

On 2006-03-20, santosh <sa*********@gm ail.com> wrote:

Richard G. Riley wrote:

Its all an else in this case since you returned.
I'm sorry, I don't get what you're trying to say here.

the "do" might just as well be in the "else" or you could not bother
with the else, e.g

if(error)
return whatever;
do other stuff;

Your version is more concise. But why not use the proper type for
strlen()'s return value? What's the reason to cast it to an unsigned
int?
See other reply. size_t is probably better, but Im waiting on a reply
to a question - its another thing Ive probably been lazy about in the
past : I just like unsigned ints for this type of stuff since then I
dont have to cast continually for printfs, logging but am willing to
be corrected if its really evil :-; Also unisgned ints are more "in
your face" for bit shifts to divide by powers of 2.

Thanks for the feedback.

[A. Sinan Unur]

"Richard G. Riley" <rg****@gmail.c om> wrote in news:did3f3-k3j.ln1
@fujitsu.mydoma in.com:

On 2006-03-20, A. Sinan Unur <1u**@llenroc.u de.invalid> wrote:

"Richard G. Riley" <rg****@gmail.c om> wrote in news:tub3f3-03i.ln1
@fujitsu.mydoma in.com:

void reverse(char * refS){
/* assume parent does parameter checks */
unsigned int len = (unsigned int)strlen(refS );
size_t len = strlen(refS);

....
I like using unsigned ints when I use bit shifts :
although I suppose I could cast it at that point so, yes, size_t is
better. But is it wrong to cast the return from strlen? What does
size_t "equate" to in the standard?

7.17 Common definitions <stddef.h>
1 The following types and macros are defined in the standard header
<stddef.h>. Some are also defined in other headers, as noted in their
respective subclauses.

2 The types are

....

size_t

which is the unsigned integer type of the result of the sizeof operator;

Sinan
--
A. Sinan Unur <1u**@llenroc.u de.invalid>
(remove .invalid and reverse each component for email address)

[Keith Thompson]

"Richard G. Riley" <rg****@gmail.c om> writes:

On 2006-03-20, A. Sinan Unur <1u**@llenroc.u de.invalid> wrote:

"Richard G. Riley" <rg****@gmail.c om> wrote in news:tub3f3-03i.ln1
@fujitsu.mydoma in.com:

void reverse(char * refS){
/* assume parent does parameter checks */
unsigned int len = (unsigned int)strlen(refS );

size_t len = strlen(refS);

Sinan

I like using unsigned ints when I use bit shifts :
although I suppose I could cast it at that point so, yes, size_t is
better. But is it wrong to cast the return from strlen? What does
size_t "equate" to in the standard?

size_t is an unsigned integer type.

"Is it wrong to cast" is the wrong question. The right question is,
"Is this cast really necessary?". If it isn't, lose it. In this
case, there will be an implicit conversion that will do exactly the
same thing the cast does -- except that the implicit conversion will
always get the type right, whereas it's easy to use the wrong type in
an explicit cast.

All casts should be viewed with suspicion.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[CBFalconer]

sudharsan wrote:

could any one please give me a code to reverse a string of more
than 1MB .???

Sure. It may not be very fast for such a size, but assuming you
can create the string in the first place it should reverse it.
Don't forget to #include <string.h>. This avoids extra calls on
strlen by returning its value.

/* =============== ======== */
/* reverse string in place */
size_t revstring(char *stg)
{
char *last, temp;
size_t lgh;

lgh = strlen(stg);
if (lgh > 1) {
last = stg + lgh; /* points to '\0' */
while (last-- > stg) {
temp = *stg; *stg++ = *last; *last = temp;
}
}
return lgh;
} /* revstring */
--
"If you want to post a followup via groups.google.c om, don't use
the broken "Reply" link at the bottom of the article. Click on
"show options" at the top of the article, then click on the
"Reply" at the bottom of the article headers." - Keith Thompson
More details at: <http://cfaj.freeshell. org/google/>
Also see <http://www.safalra.com/special/googlegroupsrep ly/>

[Richard Tobin]

In article <cv************ @fujitsu.mydoma in.com>,
Richard G. Riley <rg****@gmail.c om> wrote:

could any one please give me a code to reverse a string of more than
1MB .???

wtrite some code to reverse a string that works for 0,1,2 and 3
characters and it will probably work for a megabyte of them too. size
is no indicator of complexity.

Here's a program that reverses a string in an obvious way. It
reverses the substring after the first character and then puts the
first character onto the end, taking care to free the temporary
strings as soon as possible. It seems to work nicely for 0, 1, 2, and
3 characters.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static char *nrev(const char *old);

int main(int argc, char **argv)
{
char *old, *new;
int l;

if(argc != 2)
{
fprintf(stderr, "usage: nrev length\n");
return 2;
}

l = atoi(argv[1]);
old = malloc(l + 1);
memset(old, 'x', l);
old[l] = 0;

new = nrev(old);

return 0;
}

static char *nrev(const char *old)
{
int len;
char *new;
char *t;

len = strlen(old);
new = malloc(len+1);

if(len > 0)
{
t = nrev(old+1);
memcpy(new, t, len-1);
free(t);
new[len-1] = old[0];
}

new[len] = 0;
return new;
}

-- Richard

[Charles Krug]

On 2006-03-20, sudharsan <su*********@gm ail.com> wrote:

could any one please give me a code to reverse a string of more than
1MB .???
Thanks in advance

What have you tried that doesn't work with a 1MB string?

A favorite job interview question is to reverse a string of arbitrary
size in place.

Draw yourself a picture of an arbitrary string and figure out how you'd
reverse it in place. You should only need a single temporary.

[Richard Tobin]

In article <rc************ ********@comcas t.com>,
Charles Krug <cd****@aol.com > wrote:

Draw yourself a picture of an arbitrary string and figure out how you'd
reverse it in place. You should only need a single temporary.

You don't even need one - you can use the nul at the end of the
string...

-- Richard

[Keith Thompson]

ri*****@cogsci. ed.ac.uk (Richard Tobin) writes:

In article <rc************ ********@comcas t.com>,
Charles Krug <cd****@aol.com > wrote:

Draw yourself a picture of an arbitrary string and figure out how you'd
reverse it in place. You should only need a single temporary.

You don't even need one - you can use the nul at the end of the
string...

Yes, if saving a single temporary object is worth writing abominably
ugly code.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.