I made a booboo

Anyone know how to fix this lump of shit to reverse a text string?  Fffuuuck

#include <iostream>
#include <string>

using namespace std;

string reverse(string& str);

void writeBackward(string s, int size)
{
   if (size > 0)
   {  // write the last character
      cout << s.substr(size-1, 1);
 
      // write the rest of the string backward
      writeBackward(s, size-1);  // Point A
   }  // end if
 
   // size == 0 is the base case - do nothing
}  // end writeBackward
int main()
{
    string s = "Hello there";
cout << "s has " << s.length() << " characters." << endl;
   string theString = "";

   cout << "Enter a (backward) string: ";
   getline(cin, theString);

   cout << reverse(theString) << endl;

   return 0;
}  // end main

string reverse(string& s, int size)
{
   
   // Implement me!!!
}  // end reverse


string reverse(string& s) {
  string t = "";
  for (const_reverse_iterator<char> iterator = s.const_reverse_iterator.rbegin(); iterator != s.const_reverse_iterator.rend(); iterator++) {
    t += *iterator;
  }
  s = t;
}

(reverse "string") ;=> "gnirts"

string reverse(string& s)
  {
    string t;
    for (const_reverse_iterator<char> iterator = s.const_reverse_iterator.rbegin(); iterator != s.const_reverse_iterator.rend(); ++iterator)
      {
        t += *iterator;
      }
    return t;
  }

public String reverse(String s)
{   StringBuilder buf = new StringBuilder();
    for (int i = s.length() - 1; i >= 0; i--)
    {   buf.append(s.charAt(i));
    }
    return buf.toString();
}

Oh forgot to explain that the solution I am working towards needs to be recursive for who knows what reason.

reverse = lambda a: a[-1] + reverse(a[1:-1]) + a[0] if len(a) > 1 else a

reverse x

Simple one that only works on linked lists:

(defun my-reverse (list)
       (reduce #'(lambda (a r) (cons r a)) list :initial-value nil))
Writing one that works on generic sequences is a bit longer.

Of course, why write one when the language provides it for you.

string reverse(string& s)
      {
        if (s.length() == 0)
            return s;
        else
          {
            return s[s.length()-1] + reverse(s.substr(0, s.length() - 1));
          }
      }

[code]'GRUNNAR'[code]

this would be so easy in C, but you had to go and use sepples.
damn, i can't even read it without my eyes vomiting (YES, MY EYES ARE VOMITING).

'GRUNNAR'

'GRUNNUR'

'GRUNNUR'

you could, you know, just (reverse (string->list (read))) it in

>>17

you and your fictional programming language

>>18
R5RS.

>>11
Ok thats awesome, but how do I keep it from closing after execution?

>>20
Please troll elsewhere!

>>18
Lrn2pleac

>>20
Wut. It's supposed to close. It's done.



;assume ds:[bp+4] points to zero terminated string beginning
ReverseString2    proc    near
    pusha
   
    xor    cx, cx
    mov    bx. [bp+4]

    jmp    COMPARE
STORE:    push    cx
    inc    bx
COMPARE:    mov    cl, [bx]
    inc    cx
    loop    STORE

    mov    cx, bp
    sub    cx, sp
    shr    cx, 1
    mov    bx, [bp+4]
   
WRITE:    pop    [bx]   
    inc    bx
    loop    WRITE
   
    ret
ReverseString2     endp

Please disregard >>24

ReverseString2  proc    near
                pusha
   
                xor cx, cx
                mov bx. [bp+4]

                jmp COMPARE
STORE:          push    cx
                inc bx
COMPARE:        mov cl, [bx]
                inc cx
                loop    STORE

                mov cx, bp
                sub cx, sp
                shr cx, 1
                mov bx, [bp+4]
   
WRITE:          pop [bx]   
                inc bx
                loop    WRITE
   
                popa
                ret
ReverseString2  endp

fuck and [bp+4] should be mov, bx bp; add bx, 4

"reverse" < aðal ! {
aðal -> stef (;)
    stofn
        \skrifastreng \reverse "Hax my anus"
    stofnlok

reverse -> stef(;s)
    ;; Reverses a string in-place.
    staðvær t, i, l := \lengd s, j := l
    stofn
        fyrir (i := 1; i < j; i := \stækka i, j := \minnka j) lykkja
            t := s[i],
            s[i] := s[j],
            s[j] := t
        lykkjulok,
        s
    stofnlok  
}
*
"GRUNNUR"
;

It took me a while to figure out that Fjölnir strings are actually indexed from 1 to n, not 0 to n-1. Further, Fjölnir strings are prefixed with a length byte (presumably the maximum length is 255...), which, if you don't know about the 1 to n indexing, can easily be overwritten with a careless s[0] := 'a' or equivalent. Fjölnir never ceases to surprise me.

>>11,2,4

string reverse(const string& s) {
    return string(s.rbegin(), s.rend());
}

>>27
Pascal on beer?