Return Styles: Pseud0ch, Terminal, Valhalla, NES, Geocities, Blue Moon. Entire thread

C reversing a string

Name: Anonymous 2012-10-29 12:00

Why does "printf("%c, reverse")" just put out "aggiN", but ("%s, reverse") outside of the loop put out "aggiNNigga" when it should do the same?

int main(int argc , char* argv [ ] ) {

    int i=0;
    int c;
    int a=0;
    char string[]="Nigga";
    char reverse[20];

    i=sizeof(string);
    printf("%d\n", (i-1));

        for(c=i-2;c>=0;c--)
        {
            reverse[a]=string[c];
                        printf("%c", reverse[a]);
                        a++;

        }
    printf("\n%s", reverse);
    return 0;
}

Name: Anonymous 2012-10-29 12:10

Use code tags and clean up your disgusting code, ``faggot".


int main(int argc, char* argv [])
{

    int strSz = 0;
    int i = 0;
    int a = 0;
    char string[] = "Nigga";
    char reverse[20];

    strSz = sizeof(string);
    printf("%d\n", (strSz - 1));

    for(i = strSz - 2; i >= 0; i--)
    {
        reverse[a] = string[i];
        printf("%c", reverse[a]);
        a += 1;
    }
    printf("\n%s", reverse);

    return 0;
}

Name: Anonymous 2012-10-29 12:33

char * reverse(const char * in, char * out, size_t out_len){
    out[out_len - 1] = 0;
    int i = 0;
    while(!(ou_str[out_len - 1 - i] = in_str[i]))
        ++i;
    return &(ou_str[out_len - 1 - i]);
}
out must point to a big enough buffer

should be pretty efficient

Name: Anonymous 2012-10-29 12:35

>>3
char * reverse(const char * in, char * out, size_t out_len){
    out[out_len - 1] = 0;
    int i = 0;
    while(!(out[out_len - 1 - i] = in_str[i]))
        ++i;
    return &(out[out_len - 1 - i]);
}

corrected

Name: Anonymous 2012-10-29 12:38

i should be type size_t as well

Name: Anonymous 2012-10-29 13:13

>>2012                      `
>not just pushing and popping off the stack
>still using C
ISHYGDDT

Name: Anonymous 2012-10-29 16:46

>>6
I suppose.

void reverse(char * in, char ** out){
    if(in[1])
        reverse(in + 1, out);
    **out++ = *in;
}

Name: Anonymous 2012-10-29 16:48

>>7
SEGFAULT quality!

Name: Anonymous 2012-10-29 16:53

>>6
le /g/ face when le reddit

Name: Anonymous 2012-10-29 16:55

Symta:

reverse [X@Xs]=[@Xs X]

C/C++:

char * reverse(const char * in, char * out, size_t out_len){
    out[out_len - 1] = 0;
    int i = 0;
    while(!(out[out_len - 1 - i] = in_str[i]))
        ++i;
    return &(out[out_len - 1 - i]);
}

Name: Anonymous 2012-10-29 16:56

>>10

Symta:

f !?.??+1 [ø@X]

Haskell:

module Main
where

import List
import Control.Arrow

type Comparator a = (a -> a -> Ordering)

ascending :: (Ord a) => (b -> a) -> Comparator b
ascending f x y = compare (f x) (f y)

descending :: (Ord a) => (b -> a) -> Comparator b
descending = flip . ascending

secondary :: Comparator a -> Comparator a -> Comparator a
secondary f g x y = case f x y of {
                    EQ -> g x y;
                    z  -> z; }

-- Returns a list of unique elements together with their frequency. Listed in decreasing order of frequency, followed by
increasing order of the elements.
count :: (Ord a) => [a] -> [(a, Int)]
count = map (head &&& length) . sortBy (descending length `secondary` ascending head) . group . sort

main :: IO ()
main = interact $ unlines . map (\(x, y) -> (take 20 $ x ++ repeat ' ')  ++ " : " ++ show y) . count . words

Name: Anonymous 2012-10-29 16:56

>>8
How come? Not evaluating in[0] ?
Or **out++ = *in; instead of
**out = *in;
++out;

Name: Anonymous 2012-10-29 16:59

>>10,11
Have you tried Symta?

Name: Anonymous 2012-10-29 17:01

>>13
I tried your mom.

Name: Anonymous 2012-10-29 17:03

>>11
Haskell:
reverse = foldl (flip (:)) []

Name: Anonymous 2012-10-29 17:10

APL:
⌽
J:
|.

Name: Anonymous 2012-10-29 17:39

>>11
Look into instance Monoid Ordering.

Name: Anonymous 2012-10-29 17:46

where's the java version of this!?

Name: Anonymous 2012-10-29 17:56

public class Shit{
    public static void main(String[] args){
        System.out.print("char * reverse(const char * in, char * out, size_t out_len){\nout[out_len - 1] = 0;\nint i = 0;\nwhile(!(out[out_len - 1 - i] = in_str[i]))\n++i;\nreturn &(out[out_len - 1 - i]);}");
    }
}

the line breaks are stylistic ofc

Name: Anonymous 2012-10-29 18:16

>>7

void reverse(char* in, char* out, int size) {
    out[size] = 0;
    rev(in, out+size-1);
}

void rev(char* in, char* out) {
    if (*in) rev(in+1, out-1);
    *out = *in;
}

Name: Anonymous 2012-10-29 18:24

>>20
that out[size] = 0; is just asking to SEGFAULT

and if you put the *out = *in attribution on top you wouldn't need to keep everything on stack

Name: Anonymous 2012-10-29 18:30

>>21
The size is the one as reported by strlen(in), so it shouldn't segfault. Mayhaps a better idea would be

void reverse(char* in, char* out) {
    int sz = strlen(in);
    out[size] = 0;
    rev(in, out+size-1);
}

But this wouldn't exactly be ideal, in my opinion.

You're right about the stack thing, though, it's completely unnecessary. I forgot, is TCO a thing in C compilers or is gcc the only one that supports it?

void rev(char* in, char* out) {
    for (;;) {
        *out = *in;
        if (*in) { in++; out--; }
        else { return; }
    }
}

Name: Anonymous 2012-10-29 18:33

>>22

-    int sz = strlen(in);
+    int size = strlen(in);

Name: Anonymous 2012-10-29 18:35

>>22
the address of the last element of an array of x elements is index x - 1, not x

Name: Anonymous 2012-10-29 18:36

>>24
That's not what strlen returns.

The length of a C string is determined by the terminating null-character: A C string is as long as the number of characters between the beginning of the string and the terminating null character (without including the terminating null character itself).

This should not be confused with the size of the array that holds the string. For example:

char mystr[100]="test string";

defines an array of characters with a size of 100 chars, but the C string with which mystr has been initialized has a length of only 11 characters. Therefore, while sizeof(mystr) evaluates to 100, strlen(mystr) returns 11.

Name: Anonymous 2012-10-29 18:40

>>25
sizeof is not standard C

But yes you're right the string fits perfectly, my mistake

Name: Anonymous 2012-10-29 18:43

Stroustrup > Ritchie

is there any doubt anymore?

Name: Anonymous 2012-10-29 18:44

It's 2012. Put C in the trash. Learn D.

Name: Anonymous 2012-10-29 18:45

>>26
That was an example from http://www.cplusplus.com/reference/clibrary/cstring/strlen/. I didn't write it. I'm glad we reached an agreement.



void reverse(char* in, char* out) {
    out += strlen(in);
    *out-- = '\0';
    while (*in) {
        *out-- = *in++;
    }
}

Name: Anonymous 2012-10-29 19:37

>>26
sizeof is not standard C

The fuck? It's been a standard operator since ANSI.

Name: Anonymous 2012-10-29 20:01

>>19
thank you!

Name: Anonymous 2012-10-29 20:08

*Nigger

Name: Anonymous 2012-10-29 20:36

>>30
I know I had a brain fart, thinking about typeof, I was so embarrassed with the aberration I just said that I closed the computer and went outside

Name: Anonymous 2012-10-30 0:09

>>33-san-duku

Name: Anonymous 2012-10-30 2:38

>>33
I know that feel bro

Name: Anonymous 2012-10-30 12:42

Now in D


string reverse(string str)
{
    import std.range;

    return retro(str);
}

Name: Anonymous 2012-10-30 18:09

>>36
Go to bed, Alexandrescu.

Name: Anonymous 2012-10-31 9:21

Someone have the Fortran code to this?

Name: Anonymous 2012-10-31 11:05

>>15
try harder.

Symta:

reverse X = f [??@?] X

Haskell:

reverse = foldl (flip (:)) []

Name: Anonymous 2012-10-31 11:39

>>39

What the fuck are you trying to prove?

Here it is in APL: ⌽

According to your logic, APL is a better language than Symta...?
Newer Posts
Don't change these.
Name: Email:
Entire Thread Thread List
All trademarks and copyrights on this site are owned by their respective parties. All comments and posts are the responsibility of their own posters.
- Tinychan + 2ch Mode -