## Go

Functions below assume UTF-8 encoding.  (The task mentions Unicode but does not specify an encoding.)  Strings in Go are not restricted to be UTF-8, but Go has good support for it and works with UTF-8 most natually.  As shown below, certain string conversions work in UTF-8 and the range clause over a string works in UTF-8.  Go also has a Unicode package in the standard library that makes easy work of recognizing combining characters for this task.

```go
package main

import (
    "fmt"
    "unicode"
    "unicode/utf8"
)

// no encoding
func reverseBytes(s string) string {
    r := make([]byte, len(s))
    for i := 0; i < len(s); i++ {
        r[i] = s[len(s)-1-i]
    }
    return string(r)
}

// reverseCodePoints interprets its argument as UTF-8 and ignores bytes
// that do not form valid UTF-8.  return value is UTF-8.
func reverseCodePoints(s string) string {
    r := make([]rune, len(s))
    start := len(s)
    for _, c := range s {
        // quietly skip invalid UTF-8
        if c != utf8.RuneError {
            start--
            r[start] = c
        }
    }
    return string(r[start:])
}

// reversePreservingCombiningCharacters interprets its argument as UTF-8
// and ignores bytes that do not form valid UTF-8.  return value is UTF-8.
func reversePreservingCombiningCharacters(s string) string {
    if s == "" {
        return ""
    }
    p := []rune(s)
    r := make([]rune, len(p))
    start := len(r)
    for i := 0; i < len(p); {
        // quietly skip invalid UTF-8
        if p[i] == utf8.RuneError {
            i++
            continue
        }
        j := i + 1
        for j < len(p) && (unicode.Is(unicode.Mn, p[j]) ||
            unicode.Is(unicode.Me, p[j]) || unicode.Is(unicode.Mc, p[j])) {
            j++
        }
        for k := j - 1; k >= i; k-- {
            start--
            r[start] = p[k]
        }
        i = j
    }
    return (string(r[start:]))
}

func main() {
    test("asdf")
    test("as⃝df̅")
}

func test(s string) {
    fmt.Println("\noriginal:      ", []byte(s), s)
    r := reverseBytes(s)
    fmt.Println("reversed bytes:", []byte(r), r)
    fmt.Println("original code points:", []rune(s), s)
    r = reverseCodePoints(s)
    fmt.Println("reversed code points:", []rune(r), r)
    r = reversePreservingCombiningCharacters(s)
    fmt.Println("combining characters:", []rune(r), r)
}

{{out}}

original:       [97 115 100 102] asdf
reversed bytes: [102 100 115 97] fdsa
original code points: [97 115 100 102] asdf
reversed code points: [102 100 115 97] fdsa
combining characters: [102 100 115 97] fdsa

original:       [97 115 226 131 157 100 102 204 133] as⃝df̅
reversed bytes: [133 204 102 100 157 131 226 115 97] ��fd���sa
original code points: [97 115 8413 100 102 773] as⃝df̅
reversed code points: [773 102 100 8413 115 97] ̅fd⃝sa
combining characters: [102 773 100 115 8413 97] f̅ds⃝a

Groovy

==Solution:==

println "Able was I, 'ere I saw Elba.".reverse()

{{out}}

.ablE was I ere' ,I saw elbA

==Extra Credit:==

def string = "as⃝df̅"

List combiningBlocks = [
    Character.UnicodeBlock.COMBINING_DIACRITICAL_MARKS,
    Character.UnicodeBlock.COMBINING_DIACRITICAL_MARKS_SUPPLEMENT,
    Character.UnicodeBlock.COMBINING_HALF_MARKS,
    Character.UnicodeBlock.COMBINING_MARKS_FOR_SYMBOLS
]
List chars = string as List
chars[1..-1].eachWithIndex { ch, i ->
    if (Character.UnicodeBlock.of((char)ch) in combiningBlocks) {
        chars[i..(i+1)] = chars[(i+1)..i]
    }
}
println chars.reverse().join()

{{out}}

f̅ds⃝a

Harbour

FUNCTION Reverse( sIn )

   LOCAL cOut := "", i

   FOR i := Len( sIn ) TO 1 STEP -1
      cOut += Substr( sIn, i, 1 )
   NEXT

   RETURN cOut

Haskell

reverse = foldl (flip (:)) []

This function as defined in the Haskell Prelude.

Though variants using a helper function with an additional accumulator argument are more efficient, and are now used by default in GHC.List unless the USE_REPORT_PRELUDE key is set.

Perhaps, for example:

accumulatingReverse :: [a] -> [a]
accumulatingReverse lst =
  let rev xs a = foldl (flip (:)) a xs
  in rev lst []

Supporting combining characters

import Data.Char (isMark)
import Data.List (groupBy)
myReverse = concat . reverse . groupBy (const isMark)

groupBy (const isMark) is an unusual way of splitting a string into its combined characters

HicEst

CHARACTER string = "Hello World", tmp

L = LEN( string )
DO i = 1, L/2
  tmp = string(i)
  string(i) = string(L-i+1)
  string(L-i+1) = tmp
ENDDO

WRITE(Messagebox, Name) string

=={{header|Icon}} and {{header|Unicon}}==

procedure main(arglist)
s := \arglist[1] | "asdf"
write(s," <-> ", reverse(s))    # reverse is built-in
end

Io

"asdf" reverse

J

Reverse (|.) reverses a list of items (of any shape or type).

   |.'asdf'
fdsa

Extra credit: First, a function to determine whether a Unicode character is a combining character:

   ranges=.16b02ff 16b036f, 16b1dbf 16b1dff, 16b20cf 16b20ff, 16bfe1f 16bfe2f
   iscombining=. 2 | ranges&I.

Then we need to box groups of letters and combining characters, reverse, and unbox. The boxing function can be carried out easily with dyad cut, which uses the indices of the ones on the right as the starting points for groups of characters. For clarity, its inverse will be defined as raze, which simply runs together the items inside boxes of its argument.

   split=. (<;.1~ -.@iscombining) :. ;

After this, the solution is just to reverse under the split transformation. This also takes place under J code to convert from Unicode to integers.

   |.&.split&.(3 u: 7&u:) 'as⃝df̅'
f̅ds⃝a

Java

public static String reverseString(String s) {
    return new StringBuffer(s).reverse().toString();
}

{{works with|Java|1.5+}}

public static String reverseString(String s) {
    return new StringBuilder(s).reverse().toString();
}

JavaScript

ES5

//using chained methods
function reverseStr(s) {
  return s.split('').reverse().join('');
}

//fast method using for loop
function reverseStr(s) {
  for (var i = s.length - 1, o = ''; i >= 0; o += s[i--]) { }
  return o;
}

//fast method using while loop (faster with long strings in some browsers when compared with for loop)
function reverseStr(s) {
  var i = s.length, o = '';
  while (i--) o += s[i];
  return o;
}

ES6

(() => {

    // .reduceRight() can be useful when reversals
    // are composed with some other process

    let reverse1 = s => Array.from(s)
        .reduceRight((a, x) => a + (x !== ' ' ? x : ' <- '), ''),

        // but ( join . reverse . split ) is faster for
        // simple string reversals in isolation

        reverse2 = s => s.split('').reverse().join('');


    return [reverse1, reverse2]
        .map(f => f("Some string to be reversed"));

})();

{{Out}}

["desrever <- eb <- ot <- gnirts <- emoS", "desrever eb ot gnirts emoS"]

jq

jq's explode/implode filters are based on codepoints, and therefore "reverse_string" as defined here will reverse the sequence of codepoints. The topic of Unicode combining characters is a large one that is not touched on here.

def reverse_string: explode | reverse | implode;

'''Examples''': "nöel" | reverse_string # => "leön"

"as⃝df̅" | reverse_string # => "̅fd⃝sa"

Jsish

ECMAScript has no builtin string reversal, so split the characters into an array, reverse the array and join it back together.

Jsi only supports UTF-8 literals so far (in release 2.8), character by character manipulation routines of multibyte UTF-8 data will not be correct. No extra credit, ''yet''.

var str = "Never odd or even";
puts(str);
puts(str.split('').reverse().join(''));

{{out}}

Never odd or even
neve ro ddo reveN

Julia

 reverse("hey")
"yeh"

The reverse function reverses codepoints ([https://github.com/JuliaLang/julia/issues/6165 because this is the right behavior] for the main application of string reversal: reversed string processing by external C libraries). However, [https://github.com/JuliaLang/julia/pull/9261 starting in Julia 0.4], you can also reverse the graphemes if you want (i.e. to reverse "visual order" including combining characters etc.) by:

 join(reverse(collect(graphemes("as⃝df̅"))))
"f̅ds⃝a"

K

Monadic reverse (| ) verb reverses a string or list of any shape

     |"asdf"
"fdsa"

     | 23 4 5 1
1 5 4 23

Kotlin

fun main(args: Array<String>) {
    println("asdf".reversed())
}

L++

(include "string" "algorithm")
(main
  (decl std::string s)
  (std::getline std::cin s)
  (std::reverse (s.begin) (s.end))
  (prn s))

LabVIEW

{{VI solution|LabVIEW_Reverse_a_string.png}}

Lang5

: flip "" split reverse "" join ;
"qwer asdf" flip .

Lasso

local(input) = 'asdf'
#input->reverse

===Using Query Expression & Array=== More verbose than the string->reverse method, but this example illustrates different techniques to achieve the same result: using string->values to iterate over a string in order, inserting at position 1, and joining the resulting array as a string.

local(input = 'asdf', output = array)
with i in #input->values
do #output->insertFirst(#i)
#output->join

LC3 Assembly

A string is stored as a zero-terminated array of character codes. To reverse it, we first scan forwards until we find the end; we then move backwards again, copying each code into a block of memory we have reserved for the purpose; and finally, when we have got back to the beginning, we append a terminal zero to the new string we have created. We can then call PUTS to print it.

        .ORIG      0x3000

        LEA        R1,STRING
        LEA        R2,GNIRTS
        LD         R3,MINUS1
        NOT        R5,R1
        ADD        R5,R5,1

SCAN    LDR        R4,R1,0
        BRZ        COPY
        ADD        R1,R1,1
        BRNZP      SCAN

COPY    ADD        R1,R1,R3
        ADD        R4,R1,R5
        BRN        COPIED
        LDR        R4,R1,0
        STR        R4,R2,0
        ADD        R2,R2,1
        BRNZP      COPY

COPIED  AND        R4,R4,0
        STR        R4,R2,0

        LEA        R0,GNIRTS
        PUTS

        HALT

MINUS1  .FILL      0xFFFF

STRING  .STRINGZ   "If thou beest he -- but O how fall'n! how chang'd"
GNIRTS  .BLKW      128

        .END

{{out}}

d'gnahc woh !n'llaf woh O tub -- eh tseeb uoht fI

LFE

Ordinary string:

> (lists:reverse "asdf")
"fdsa"

Create a UTF-8 encoded string:

> (set encoded (binary ("åäö ð" utf8)))
#B(195 165 195 164 195 182 32 195 176)

Display it, to be sure:

> (io:format "~tp~n" (list encoded))
<<"åäö ð"/utf8>>

Reverse it:

> (lists:reverse (unicode:characters_to_list encoded))
"ð öäå"

Liberty BASIC

input$ ="abcdefgABCDEFG012345"
print input$
print ReversedStr$( input$)

end

function ReversedStr$(in$)
    for i =len(in$) to 1 step -1
    ReversedStr$ =ReversedStr$ +mid$( in$, i, 1)
    next i
end function

Lingo

Lingo strings are always UTF-8 encoded and string operations are based on Unicode code points, so the "extra credit" is built-in:

on reverse (str)
  res = ""
  repeat with i = str.length down to 1
    put str.char[i] after res
  end repeat
  return res
end

To reverse a string byte-wise, the ByteArray data type has to be used:

on reverseBytes (str)
  ba = byteArray(str)
  res = byteArray()
  repeat with i = ba.length down to 1
    res[res.length+1] = ba[i]
  end repeat
  return res
end

LiveCode

function reverseString S
   repeat with i = length(S) down to 1
      put char i of S after R
   end repeat
   return R
end reverseString

LLVM

; This is not strictly LLVM, as it uses the C library function "printf".
; LLVM does not provide a way to print values, so the alternative would be
; to just load the string into memory, and that would be boring.

; Additional comments have been inserted, as well as changes made from the output produced by clang such as putting more meaningful labels for the jumps

$"main.printf" = comdat any

@main.str = private unnamed_addr constant [12 x i8] c"Hello world\00", align 1
@"main.printf" = linkonce_odr unnamed_addr constant [4 x i8] c"%s\0A\00", comdat, align 1

define void @reverse(i64, i8*) {
  %3 = alloca i8*, align 8          ; allocate str (local)
  %4 = alloca i64, align 8          ; allocate len (local)
  %5 = alloca i64, align 8          ; allocate i
  %6 = alloca i64, align 8          ; allocate j
  %7 = alloca i8, align 1           ; allocate t
  store i8* %1, i8** %3, align 8    ; set str (local) to the parameter str
  store i64 %0, i64* %4, align 8    ; set len (local) to the paremeter len
  store i64 0, i64* %5, align 8     ; i = 0
  %8 = load i64, i64* %4, align 8   ; load len
  %9 = sub i64 %8, 1                ; decrement len
  store i64 %9, i64* %6, align 8    ; j =
  br label %loop

loop:
  %10 = load i64, i64* %5, align 8  ; load i
  %11 = load i64, i64* %6, align 8  ; load j
  %12 = icmp ult i64 %10, %11       ; i < j
  br i1 %12, label %loop_body, label %exit

loop_body:
  %13 = load i8*, i8** %3, align 8                  ; load str
  %14 = load i64, i64* %5, align 8                  ; load i
  %15 = getelementptr inbounds i8, i8* %13, i64 %14 ; address of str[i]
  %16 = load i8, i8* %15, align 1                   ; load str[i]
  store i8 %16, i8* %7, align 1                     ; t = str[i]
  %17 = load i64, i64* %6, align 8                  ; load j
  %18 = getelementptr inbounds i8, i8* %13, i64 %17 ; address of str[j]
  %19 = load i8, i8* %18, align 1                   ; load str[j]
  %20 = getelementptr inbounds i8, i8* %13, i64 %14 ; address of str[i]
  store i8 %19, i8* %20, align 1                    ; str[i] = str[j]
  %21 = load i8, i8* %7, align 1                    ; load t
  %22 = getelementptr inbounds i8, i8* %13, i64 %17 ; address of str[j]
  store i8 %21, i8* %22, align 1                    ; str[j] = t

;-- loop increment
  %23 = load i64, i64* %5, align 8  ; load i
  %24 = add i64 %23, 1              ; increment i
  store i64 %24, i64* %5, align 8   ; store i
  %25 = load i64, i64* %6, align 8  ; load j
  %26 = add i64 %25, -1             ; decrement j
  store i64 %26, i64* %6, align 8   ; store j
  br label %loop

exit:
  ret void
}

define i32 @main() {
;-- char str[]
  %1 = alloca [12 x i8], align 1
;-- memcpy(str, "Hello world")
  %2 = bitcast [12 x i8]* %1 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %2, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @main.str, i32 0, i32 0), i64 12, i32 1, i1 false)
;-- printf("%s\n", str)
  %3 = getelementptr inbounds [12 x i8], [12 x i8]* %1, i32 0, i32 0
  %4 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @"main.printf", i32 0, i32 0), i8* %3)
;-- %7 = strlen(str)
  %5 = getelementptr inbounds [12 x i8], [12 x i8]* %1, i32 0, i32 0
  %6 = call i64 @strlen(i8* %5)
;-- reverse(%6, str)
  call void @reverse(i64 %6, i8* %5)
;-- printf("%s\n", str)
  %7 = getelementptr inbounds [12 x i8], [12 x i8]* %1, i32 0, i32 0
  %8 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @"main.printf", i32 0, i32 0), i8* %7)
;-- end of main
  ret i32 0
}

;--- The declaration for the external C printf function.
declare i32 @printf(i8*, ...)

; Function Attrs: argmemonly nounwind
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32, i1)

declare i64 @strlen(i8*)

{{out}}

Hello world
dlrow olleH

Logo

REVERSE works on both words and lists.

print reverse "cat   ; tac

Lua

Built-in string.reverse(s) or s:reverse().

theString = theString:reverse()

M2000 Interpreter

Using Custom Function

Version 2, using insert to string (with no copies of strings)

Module ReverseString {
      a$="as⃝df̅"
      Print Len(a$), len.disp(a$)
      Let i=1, j=Len(a$)
      z$=String$(" ",j)
      j++
      do {
            k$=mid$(a$, i, 1)
            if i<len(a$) then {
                  while len.disp(k$+mid$(a$, i+1,1)) =len.disp(k$)  {
                        k$+=mid$(a$, i+1,1)
                        i++
                        if i>len(a$) then exit
                        j--
                  }
                  j--
                  insert j, len(k$) Z$=K$
            } else j-- :Insert j,1 z$=k$
            if i>=len(a$) then exit
            i++
      } Always
      Print len(z$), len.disp(z$)
      Print z$="f̅ds⃝a"
      Print z$
}
ReverseString

===using StrRev$()=== this function (new to 9.5 version) use StrReverse from Vb6

a$="as⃝df̅"
b$=strrev$(a$)
clipboard b$
Print b$="̅fd⃝sa"

M4

define(`invert',`ifelse(len(`$1'),0,,`invert(substr(`$1',1))'`'substr(`$1',0,1))')

Maclisp

(readlist (reverse (explode "my-string")))

Output:

"gnirts-ym"

Maple

 StringTools:-Reverse( "foo" );
                                 "oof"

Mathematica

StringReverse["asdf"]

MATLAB

A built-in function, "fliplr(string)" handles reversing a string of ASCII characters. Unicode is a whole other beast, if you need this functionality test to see if "fliplr()" properly handles the unicode characters you use. If it doesn't then you will need to code a function that is specific to your application.

Sample Usage:

 fliplr(['She told me that she spoke English and I said great. '...
'Grabbed her hand out the club and I said let''s skate.'])

ans =

.etaks s'tel dias I dna bulc eht tuo dnah reh debbarG .taerg dias I dna hsilgnE ekops ehs taht em dlot ehS

Maxima

sreverse("abcdef");         /* "fedcba" */

sreverse("rats live on no evil star");   /* not a bug :o) */

MAXScript

fn reverseString s =
(
    local reversed = ""
    for i in s.count to 1 by -1 do reversed += s[i]
    reversed
)

min

{{works with|min|0.19.3}}

("" split reverse "" join) :reverse-str

MiniScript

str = "This is a string"
print "Forward: " + str
newStr = ""
for i in range(str.len-1, 0)
    newStr = newStr + str[i]
end for
print "Reversed: " + newStr

{{out}}

Forward: This is a string
Reversed: gnirts a si sihT

MIPS Assembly

This is heavily based off of the [http://rosettacode.org/wiki/Copy_a_string#MIPS_Assembly Copy String] solution. Only a few lines are changed. In the Copy String solution, the pointer at the source string starts at 0th then keeps adding until the loaded byte isn't 0. This instead when copying the string starts at the ''last'' index, then decrements the source pointer a number of times equal to the determined string length.

# First, it gets the length of the original string
# Then, it allocates memory from the copy
# Then it copies the pointer to the original string, and adds the strlen
#     subtract 1, then that new pointer is at the last char.
# while(strlen)
#     copy char
#     decrement strlen
#     decrement source pointer
#     increment target pointer

.data
	ex_msg_og: .asciiz "Original string:\n"
	ex_msg_cpy: .asciiz "\nCopied string:\n"
	string: .asciiz "Wow, what a string!"

.text
	main:
		la $v1,string #load addr of string into $v0
		la $t1,($v1)  #copy addr into $t0 for later access
		lb $a1,($v1)  #load byte from string addr
	strlen_loop:
		beqz $a1,alloc_mem
		addi $a0,$a0,1 #increment strlen_counter
		addi $v1,$v1,1 #increment ptr
		lb $a1,($v1)   #load the byte
		j strlen_loop

	alloc_mem:
		li $v0,9 #alloc memory, $a0 is arg for how many bytes to allocate
		         #result is stored in $v0
		syscall
		la $t0,($v0) #$v0 is static, $t0 is the moving ptr
		la $v1,($t1) #get a copy we can increment

		add $t1,$t1,$a0 #add strlen to our original, static addr to equal last char
		subi $t1,$t1,1  #previous operation is on NULL byte, i.e. off-by-one error.
		                #this corrects.
	copy_str:
		lb $a1,($t1) #copy first byte from source

	strcopy_loop:
		beq $a0,0,exit_procedure
		sb $a1,($t0)            #store the byte at the target pointer
		addi $t0,$t0,1          #increment target ptr
		subi $t1,$t1,1
		subi $a0,$a0,1
		lb $a1,($t1)            #load next byte from source ptr
		j strcopy_loop

	exit_procedure:
		la $a1,($v0) #store our string at $v0 so it doesn't get overwritten
		li $v0,4 #set syscall to PRINT

		la $a0,ex_msg_og  #PRINT("original string:")
		syscall

		la $a0,($v1)      #PRINT(original string)
		syscall

		la $a0,ex_msg_cpy #PRINT("copied string:")
		syscall

		la $a0,($a1)      #PRINT(strcopy)
		syscall

		li $v0,10         #EXIT(0)
		syscall

Mirah

def reverse(s:string)
    StringBuilder.new(s).reverse
end

puts reverse('reversed')

=={{header|Modula-2}}==

MODULE ReverseStr;
FROM FormatString IMPORT FormatString;
FROM Terminal IMPORT Write,WriteString,WriteLn,ReadChar;

PROCEDURE WriteInt(n : INTEGER);
VAR buf : ARRAY[0..15] OF CHAR;
BEGIN
    FormatString("%i", buf, n);
    WriteString(buf)
END WriteInt;

PROCEDURE ReverseStr(in : ARRAY OF CHAR; VAR out : ARRAY OF CHAR);
VAR ip,op : INTEGER;
BEGIN
    ip := 0;
    op := 0;
    WHILE in[ip] # 0C DO
        INC(ip)
    END;
    DEC(ip);
    WHILE ip>=0 DO
        out[op] := in[ip];
        INC(op);
        DEC(ip)
    END
END ReverseStr;

TYPE A = ARRAY[0..63] OF CHAR;
VAR is,os : A;
BEGIN
    is := "Hello World";
    ReverseStr(is, os);

    WriteString(is);
    WriteLn;
    WriteString(os);
    WriteLn;

    ReadChar
END ReverseStr.

=={{header|Modula-3}}==

MODULE Reverse EXPORTS Main;

IMPORT IO, Text;

PROCEDURE String(item: TEXT): TEXT =
  VAR result: TEXT := "";
  BEGIN
    FOR i := Text.Length(item) - 1 TO 0 BY - 1 DO
      result := Text.Cat(result, Text.FromChar(Text.GetChar(item, i)));
    END;
    RETURN result;
  END String;

BEGIN
  IO.Put(String("Foobarbaz") & "\n");
END Reverse.

{{out}}

zabrabooF

MUMPS

REVERSE
 ;Take in a string and reverse it using the built in function $REVERSE
 NEW S
 READ:30 "Enter a string: ",S
 WRITE !,$REVERSE(S)
 QUIT

{{out}}

USER>D REVERSE^ROSETTA
Enter a string: Hello, World!
!dlroW ,olleH

Neko

No extra credit for UTF in this example.

/* Reverse a string, in Neko */

var reverse = function(s) {
  var len = $ssize(s)
  if len < 2 return s

  var reverse = $smake(len)
  var pos = 0
  while len > 0 $sset(reverse, pos ++= 1, $sget(s, len -= 1))
  return reverse
}

var str = "never odd or even"
$print(str, "\n")
$print(reverse(str), "\n\n")

str = "abcdefghijklmnopqrstuvwxyz"
$print(str, "\n")
$print(reverse(str), "\n\n")

$print("single test\n")
str = "a"
$print(str, "\n")
$print(reverse(str), "\n\n")


$print("empty test\n")
str = ""
$print(str, "\n")
$print(reverse(str), "\n")

{{out}}

prompt$ nekoc reverse.neko
prompt$ neko reverse.n
never odd or even
neve ro ddo reven

abcdefghijklmnopqrstuvwxyz
zyxwvutsrqponmlkjihgfedcba

single test
a
a

empty test

Nemerle

Supporting Combining Characters

Compile with:

ncc -reference:System.Windows.Forms reverse.n

using System;
using System.Globalization;
using System.Windows.Forms;
using System.Console;
using Nemerle.Utility.NString;

module StrReverse
{
    UReverse(text : string) : string
    {
        mutable output = [];
        def elements = StringInfo.GetTextElementEnumerator(text);
        while (elements.MoveNext())
            output ::= elements.GetTextElement().ToString();
        Concat("", output.Reverse());
    }

    Main() : void
    {
        def test = "as⃝df̅";
        MessageBox.Show($"$test --> $(UReverse(test))");  //for whatever reason my console didn't display Unicode properly, but a MessageBox worked
    }
}

Basic Reverse

Doesn't require the '''System.Globalization''' namespace, probably a little less overhead.

Reverse(text : string) : string
{
    mutable output = [];
    foreach (c in text.ToCharArray())
        output ::= c.ToString();
    Concat("", output)
}

NetRexx

/* NetRexx */

options replace format comments java crossref savelog symbols nobinary

reverseThis = 'asdf'
sihTesrever = reverseThis.reverse

say reverseThis
say sihTesrever

return

{{out}}

asdf
fdsa

NewLISP

(reverse "!dlroW olleH")

Nial

reverse 'asdf'
=fdsa

Nim

import unicode

proc reverse(s: var string) =
  for i in 0 .. s.high div 2:
    swap(s[i], s[s.high - i])

proc reversed(s: string): string =
  result = newString(s.len)
  for i,c in s:
    result[s.high - i] = c

proc uniReversed(s: string): string =
  result = newStringOfCap(s.len)
  var tmp: seq[Rune] = @[]
  for r in runes(s):
    tmp.add(r)
  for i in countdown(tmp.high, 0):
    result.add(toUtf8(tmp[i]))

proc isComb(r: Rune): bool =
  (r >=% Rune(0x300) and r <=% Rune(0x36f)) or
    (r >=% Rune(0x1dc0) and r <=% Rune(0x1dff)) or
    (r >=% Rune(0x20d0) and r <=% Rune(0x20ff)) or
    (r >=% Rune(0xfe20) and r <=% Rune(0xfe2f))

proc uniReversedPreserving(s: string): string =
  result = newStringOfCap(s.len)
  var tmp: seq[Rune] = @[]
  for r in runes(s):
    if isComb(r): tmp.insert(r, tmp.high)
    else: tmp.add(r)
  for i in countdown(tmp.high, 0):
    result.add(toUtf8(tmp[i]))

for str in ["Reverse This!", "as⃝df̅"]:
  echo "Original string:       ", str
  echo "Reversed:              ", reversed(str)
  echo "UniReversed:           ", uniReversed(str)
  echo "UniReversedPreserving: ", uniReversedPreserving(str)

{{out}}

Original string:       Reverse This!
Reversed:              !sihT esreveR
UniReversed:           !sihT esreveR
UniReversedPreserving: !sihT esreveR
Original string:       as⃝df̅
Reversed:              Ìfdâsa
UniReversed:          ‾fd⃝sa
UniReversedPreserving: f̅ds⃝a

Since Nim 0.11.0, the ''unicode'' module provides a ''reversed'' proc... Hence:

import unicode

doAssert "foobar".reversed == "raboof"
doAssert "先秦兩漢".reversed == "漢兩秦先"

=={{header|NS-HUBASIC}}== 10 STRING$="THIS TEXT IS REVERSED." 20 REVERSED$="" 30 FOR I=1 TO LEN(STRING$) 40 REVERSED$=MID$(STRING$,I,1)+REVERSED$ 50 NEXT 60 PRINT REVERSED$

## Oberon

Tested with [https://miasap.se/obnc OBNC].

```Oberon
MODULE reverse;

   IMPORT Out, Strings;

   VAR s: ARRAY 12 + 1 OF CHAR;

   PROCEDURE Swap(VAR c, d: CHAR);
      VAR oldC: CHAR;
   BEGIN
      oldC := c; c := d; d := oldC
   END Swap;


   PROCEDURE Reverse(VAR s: ARRAY OF CHAR);
      VAR len, i: INTEGER;
   BEGIN
      len := Strings.Length(s);
      FOR i := 0 TO len DIV 2 DO
         Swap(s[i], s[len - 1 - i])
      END
   END Reverse;

BEGIN
   s := "hello, world";
   Reverse(s);
   Out.String(s);
   Out.Ln
END reverse.

Objeck

result := "asdf"->Reverse();

=={{header|Objective-C}}== This extends the NSString object adding a reverseString class method.

@interface NSString (Extended)
-(NSString *)reverseString;
@end

@implementation NSString (Extended)
-(NSString *) reverseString
{
    NSUInteger len = [self length];
    NSMutableString *rtr=[NSMutableString stringWithCapacity:len];
    //        unichar buf[1];

    while (len > (NSUInteger)0) {
        unichar uch = [self characterAtIndex:--len];
        [rtr appendString:[NSString stringWithCharacters:&uch length:1]];
    }
    return rtr;
}
@end

Usage example:

int main()
{
    @autoreleasepool {

        NSString *test = [@"!A string to be reverted!" reverseString];

        NSLog(@"%@", test);

    }
    return 0;
}

Supporting combining characters

Extra credit

@interface NSString (Extended)
-(NSString *)reverseString;
@end

@implementation NSString (Extended)
-(NSString *)reverseString
{
	NSInteger l = [self length] - 1;
	NSMutableString *ostr = [NSMutableString stringWithCapacity:[self length]];
	while (l >= 0)
	{
		NSRange range = [self rangeOfComposedCharacterSequenceAtIndex:l];
		[ostr appendString:[self substringWithRange:range]];
		l -= range.length;
	}
	return ostr;
}
@end

Usage example:

int main()
{
    @autoreleasepool {

        NSString *test = [@"as⃝df̅" reverseString];

        NSLog(@"%@", test);

    }
    return 0;
}

OCaml

Since OCaml 4.02 we can use the handy [http://caml.inria.fr/pub/docs/manual-ocaml/libref/String.html#VALinit String.init] function.

Here a version that returns a new allocated string (preserving the original one):

{{works with|OCaml|4.02+}}

let string_rev s =
  let len = String.length s in
  String.init len (fun i -> s.[len - 1 - i])

let () =
  print_endline (string_rev "Hello world!")

for in place modification we can't use strings anymore because strings became immutable in ocaml 4.02, so the type bytes has to be used instead:

let rev_bytes bs =
  let last = Bytes.length bs - 1 in
  for i = 0 to last / 2 do
    let j = last - i in
    let c = Bytes.get bs i in
    Bytes.set bs i (Bytes.get bs j);
    Bytes.set bs j c;
  done

let () =
  let s = Bytes.of_string "Hello World" in
  rev_bytes s;
  print_bytes s;
  print_newline ();
;;

Here is a 100% functionnal string reversing function:

let rec revs_aux strin list index =
  if List.length list = String.length strin
  then String.concat "" list
  else revs_aux strin ((String.sub strin index 1)::list) (index+1)

let revs s = revs_aux s [] 0

let () =
  print_endline (revs "Hello  World!")

will return "!dlroW olleH"

Octave

s = "a string";
rev = s(length(s):-1:1)

Oforth

## Ol


```scheme

(define (rev s)
   (runes->string (reverse (string->runes s))))

; testing:
(print (rev "as⃝df̅"))
; ==> ̅fd⃝sa

OpenEdge/Progress

<lang Progress (OpenEdge ABL)>FUNCTION reverseString RETURNS CHARACTER ( INPUT i_c AS CHARACTER ):

DEFINE VARIABLE cresult AS CHARACTER NO-UNDO. DEFINE VARIABLE ii AS INTEGER NO-UNDO.

DO ii = LENGTH( i_c ) TO 1 BY -1: cresult = cresult + SUBSTRING( i_c, ii, 1 ). END. RETURN cresult.

END FUNCTION.

MESSAGE reverseString( "asdf" ) VIEW-AS ALERT-BOX.

## OOC


```ooc

main: func {
  "asdf" reverse() println() // prints "fdsa"
}

OxygenBasic

'8 BIT CHARACTERS

string s="qwertyuiop"
sys a,b,i,j,le=len s
'
for i=1 to le
  j=le-i+1
  if j<=i then exit for
  a=asc s,i
  b=asc s,j
  mid s,j,chr a
  mid s,i,chr b
next
'

print s

'16 BIT CHARACTERS

wstring s="qwertyuiop"
sys a,b,i,j,le=len s
'
for i=1 to le
  j=le-i+1
  if j<=i then exit for
  a=unic s,i
  b=unic s,j
  mid s,j,wchr a
  mid s,i,wchr b
next
'
print s

==OxygenBasic x86 Assembler== 32 bit code, 8-bit characters:

string s="qwertyuiop"
sys p=strptr s, le=len s
mov esi,p
mov edi,esi
add edi,le
dec edi
(
 cmp esi,edi
 jge exit
 mov al,[esi]
 mov ah,[edi]
 mov [esi],ah
 mov [edi],al
 inc esi
 dec edi
 repeat
)

print s

Oz

Strings are lists. A function "Reverse" defined on lists is part of the implementation.

{System.showInfo {Reverse "!dlroW olleH"}}

An efficient (tail-recursive) implementation could look like this:

local
   fun {DoReverse Xs Ys}
      case Xs of nil then Ys
      [] X|Xr then {DoReverse Xr X|Ys}
      end
   end
in
   fun {Reverse Xs} {DoReverse Xs nil} end
end

Oz uses a single-byte encoding by default. If you decide to use a multi-byte encoding, Reverse will not work correctly.

PARI/GP

Version #1.

reverse(s)=concat(Vecrev(s))

Version #2.

{{Works with|PARI/GP|2.7.4 and above}}

\\ Return reversed string str.
\\ 3/3/2016 aev
sreverse(str)={return(Strchr(Vecrev(Vecsmall(str))))}

{
\\ TEST1
print(" *** Testing sreverse from Version #2:");
print(sreverse("ABCDEF"));
my(s,sr,n=10000000);
s="ABCDEFGHIJKL";
for(i=1,n, sr=sreverse(s));
}

{{Output}}

 *** Testing sreverse from Version #2:
FEDCBA
(17:28) gp > ##
  ***   last result computed in 8,642 ms.

\\ Version #1 upgraded to complete function. Practically the same.
reverse(str)={return(concat(Vecrev(str)))}

{
\\ TEST2
print(" *** Testing reverse from Version #1:");
print(reverse("ABCDEF"));
my(s,sr,n=10000000);
s="ABCDEFGHIJKL";
for(i=1,n, sr=reverse(s));
}

{{Output}}

 *** Testing reverse from Version #1:
FEDCBA
(17:31) gp > ##
  ***   last result computed in 11,814 ms.

Pascal

The following examples handle correctly only single-byte encodings.

Standard Pascal

The following only works on implementations which implement Level 1 of standard Pascal (many popular compilers don't).

Standard Pascal doesn't have a separate string type, but uses arrays of char for strings. Note that Standard Pascal doesn't allow a return type of char array, therefore the destination array is passed through a var parameter (which is more efficient anyway).

{ the result array must be at least as large as the original array }
procedure reverse(s: array[min .. max: integer] of char, var result: array[min1 .. max1: integer] of char);
 var
  i, len: integer;
 begin
  len := max-min+1;
  for i := 0 to len-1 do
   result[min1 + len-1 - i] := s[min + i]
 end;

{Copy and paste it in your program}
function revstr(my_s:string):string;
    var out_s:string;
    ls,i:integer;
    begin
    ls:=length(my_s);
    for i:=1 to ls do
    out_s:=out_s+my_s[ls-i+1];
    revstr:=out_s;
    end;

=== Extended Pascal, Turbo Pascal, Delphi and compatible compilers ===

function reverse(s:string):string;
var i:integer;
var tmp:char;
begin
    for i:=1 to length(s) div 2 do
      begin
       tmp:=s[i];
       s[i]:=s[length(s)+1-i];
       s[length(s)+1-i]:=tmp;
       reverse:=s;
      end;
end;

alternative as procedure which changes the original

procedure revString(var s:string);
var
  i,j:integer;
  tmp:char;
begin
  i := 1;
  j := length(s);
  while i<j do
  begin
     tmp:=s[i];
     s[i]:=s[j];
     s[j]:=tmp;
     inc(i);
     dec(j)
  end;
end;

Peloton

Padded out, variable length Chinese dialect

<# 显示 指定 变量 反转顺序 字串>集装箱|猫坐在垫子</#>

This assigns the reverse of 'the cat sat on the mat' to the variable 'container' and displays the result which is

子垫在坐猫

which Google Translate renders as

Sub-pad sitting cat

.

The same again but with everything in Korean.

<# 보이십 할당하 변물건 열거꾸 문자그>컨테이너|고양이가 매트 위에 앉아</#>

Reversing the Korean makes an untranslatable-by-Google mess of the sentence, viz

아앉 에위 트매 가이양고

.

The short-opcode version in English dialect is

集装箱|猫坐在垫子</@>

Peloton works in Unicode.

Perl

use utf8;
binmode STDOUT, ":utf8";

# to reverse characters (code points):
print reverse('visor'), "\n";

# to reverse graphemes:
print join("", reverse "José" =~ /\X/g), "\n";

$string = 'ℵΑΩ 駱駝道 🤔 🇸🇧 🇺🇸 🇬🇧‍ 👨‍👩‍👧‍👦🆗🗺';
print join("", reverse $string =~ /\X/g), "\n";

{{out}}

rosiv
ésoJ
🗺🆗👨‍👩‍👧‍👦 🇬🇧‍ 🇺🇸 🇸🇧 🤔 道駝駱 ΩΑℵ

Perl 6

{{Works with|rakudo|2018.08}} Perl 6 handles graphemes, multi-byte characters and emoji correctly by default.

say "hello world".flip;
say "as⃝df̅".flip;
say 'ℵΑΩ 駱駝道 🤔 🇸🇧 🇺🇸 🇬🇧‍ 👨‍👩‍👧‍👦🆗🗺'.flip;

{{out}}

dlrow olleh
f̅ds⃝a
🗺🆗👨‍👩‍👧‍👦 🇬🇧‍ 🇺🇸 🇸🇧 🤔 道駝駱 ΩΑℵ

Phix

?reverse("asdf")

However that would go horribly wrong on utf8 strings, even without combining characters, so... this seems ok on "as\u203Ddf\u0305", as long as it is displayed in a message box rather than a Windows Console (even with chcp 65001 and Lucida Console, the characters do not combine).

function unicode_reverse(string utf8)
sequence utf32 = utf8_to_utf32(utf8)
integer ch
    -- the assumption is made that <char><comb1><comb2>
    -- and <char><comb2><comb1> etc would work the same.
    for i=1 to length(utf32) do
        ch = utf32[i]
        if (ch>=0x300 and ch<=0x36f)
        or (ch>=0x1dc0 and ch<=0x1dff)
        or (ch>=0x20d0 and ch<=0x20ff)
        or (ch>=0xfe20 and ch<=0xfe2f) then
            utf32[i] = utf32[i-1]
            utf32[i-1] = ch
        end if
    end for
    utf32 = reverse(utf32)
    utf8 = utf32_to_utf8(utf32)
    return utf8
end function

PHP

strrev($string);

If you want Unicode support, you have to use some multibyte function. Sadly, PHP doesn't contain mb_strrev(). One of functions which support Unicode and is useful in this case is preg_split().

// Will split every Unicode character to array, reverse array and will convert it to string.
join('', array_reverse(preg_split('""u', $string, -1, PREG_SPLIT_NO_EMPTY)));

PicoLisp

(pack (flip (chop "äöüÄÖÜß")))

{{out}}

-> "ßÜÖÄüöä"

PL/I

s = reverse(s);

Pop11

define reverse_string(s);
    lvars i, l = length(s);
    for i from l by -1 to 1 do
        s(i);
    endfor;
    consstring(l);
enddefine;

plainTeX

Works well if the string has no space (spaces are gobbled).

\def\gobtoA#1\revA{}\def\gobtoB#1\revB{}
\def\reverse#1{\reversei{}#1\revA\revB\revB\revB\revB\revB\revB\revB\revB\revA}
\def\reversei#1#2#3#4#5#6#7#8#9{\gobtoB#9\revend\revB\reversei{#9#8#7#6#5#4#3#2#1}}
\def\revend\revB\reversei#1#2\revA{\gobtoA#1}
\reverse{Rosetta}
\bye

Output:

attesoR

PostScript

The following implementation works on arrays of numerics as well as characters ( string ).

/reverse{
/str exch def
/temp str 0 get def
/i 0 def
str length 2 idiv{
/temp str i get def
str i str str length i sub 1 sub get put
str str length i sub 1 sub temp put
/i i 1 add def
}repeat
str pstack
}def

{{Out}}

[1 2 3] reverse % input
[3 2 1]

(Hello World) reverse % input
(dlroW olleH)

PowerBASIC

#DIM ALL
#COMPILER PBCC 6

FUNCTION PBMAIN () AS LONG
CON.PRINT STRREVERSE$("PowerBASIC")
END FUNCTION

PowerShell

Test string

$s = "asdf"

Array indexing

Creating a character array from the end to the string's start and join it together into a string again. {{works with|PowerShell|1}}

[string]::Join('', $s[$s.Length..0])

{{works with|PowerShell|2}}

-join ($s[$s.Length..0])

{{works with|PowerShell|2}}

[array]::Reverse($s)

Regular expressions

Creating a regular expression substitution which captures every character of the string in a capture group and uses a reverse-ordered string of references to those to construct the reversed string. {{works with|PowerShell|1}}

$s -replace
      ('(.)' * $s.Length),
      [string]::Join('', ($s.Length..1 | ForEach-Object { "`$$_" }))

{{works with|PowerShell|2}}

$s -replace
      ('(.)' * $s.Length),
      -join ($s.Length..1 | ForEach-Object { "`$$_" } )

{{works with|PowerShell|3}}

[Regex]::Matches('abc','.','RightToLeft').Value -join ''

{{Out}}

cba

Prolog

{{works with|SWI Prolog}}

reverse("abcd", L), string_to_list(S,L).

{{Out}}

L = [100,99,98,97],
S = "dcba".

The main workings are hidden inside the reverse/2 predicate, so lets write one to see how it works:

accRev([H|T], A, R) :- accRev(T, [H|A], R).
accRev([], A, A).

rev(L,R) :- accRev(L,[],R).

PureBasic

Debug ReverseString("!dekrow tI")

Python

Optimized for user input

input()[::-1]

Already known string

string[::-1]

or

''.join(reversed(string))

Python: Unicode reversal

(See [http://paddy3118.blogspot.com/2009/07/case-of-disappearing-over-bar.html this article] for more information from which this is improved)

'''Note:''' How this looks may be subject to how the tool you are using to view this page can render Unicode.

import unicodedata

def ureverse(ustring):
    'Reverse a string including unicode combining characters'
    groupedchars = []
    uchar = list(ustring)
    while uchar:
        if unicodedata.combining(uchar[0]) != 0:
            groupedchars[-1] += uchar.pop(0)
        else:
            groupedchars.append(uchar.pop(0))
    # Grouped reversal
    groupedchars = groupedchars[::-1]

    return ''.join(groupedchars)

def say_string(s):
    return ' '.join([s, '=', ' | '.join(unicodedata.name(ch, '') for ch in s)])

def say_rev(s):
    print(f"Input:              {say_string(s)}")
    print(f"Character reversed: {say_string(s[::-1])}")
    print(f"Unicode reversed:   {say_string(ureverse(s))}")
    print(f"Unicode reverse²:   {say_string(ureverse(ureverse(s)))}")

if __name__ == '__main__':
    ucode = ''.join(chr(int(n[2:], 16)) for n in
                     'U+0041 U+030A U+0073 U+0074 U+0072 U+006F U+0308 U+006D'.split())
    say_rev(ucode)

{{out}}

Input:              Åström = LATIN CAPITAL LETTER A | COMBINING RING ABOVE | LATIN SMALL LETTER S | LATIN SMALL LETTER T | LATIN SMALL LETTER R | LATIN SMALL LETTER O | COMBINING DIAERESIS | LATIN SMALL LETTER M
Character reversed: m̈orts̊A = LATIN SMALL LETTER M | COMBINING DIAERESIS | LATIN SMALL LETTER O | LATIN SMALL LETTER R | LATIN SMALL LETTER T | LATIN SMALL LETTER S | COMBINING RING ABOVE | LATIN CAPITAL LETTER A
Unicode reversed:   mörtsÅ = LATIN SMALL LETTER M | LATIN SMALL LETTER O | COMBINING DIAERESIS | LATIN SMALL LETTER R | LATIN SMALL LETTER T | LATIN SMALL LETTER S | LATIN CAPITAL LETTER A | COMBINING RING ABOVE
Unicode reverse²:   Åström = LATIN CAPITAL LETTER A | COMBINING RING ABOVE | LATIN SMALL LETTER S | LATIN SMALL LETTER T | LATIN SMALL LETTER R | LATIN SMALL LETTER O | COMBINING DIAERESIS | LATIN SMALL LETTER M

If this code is then used:

ucode = ''.join(chr(int(n[2:], 16)) for n in
                 'U+006B U+0301 U+0075 U+032D U+006F U+0304 U+0301 U+006E'.split())
say_rev(ucode)

It produces this output {{out}}

Input:              ḱṷṓn = LATIN SMALL LETTER K | COMBINING ACUTE ACCENT | LATIN SMALL LETTER U | COMBINING CIRCUMFLEX ACCENT BELOW | LATIN SMALL LETTER O | COMBINING MACRON | COMBINING ACUTE ACCENT | LATIN SMALL LETTER N
Character reversed: ń̄o̭úk = LATIN SMALL LETTER N | COMBINING ACUTE ACCENT | COMBINING MACRON | LATIN SMALL LETTER O | COMBINING CIRCUMFLEX ACCENT BELOW | LATIN SMALL LETTER U | COMBINING ACUTE ACCENT | LATIN SMALL LETTER K
Unicode reversed:   nṓṷḱ = LATIN SMALL LETTER N | LATIN SMALL LETTER O | COMBINING MACRON | COMBINING ACUTE ACCENT | LATIN SMALL LETTER U | COMBINING CIRCUMFLEX ACCENT BELOW | LATIN SMALL LETTER K | COMBINING ACUTE ACCENT
Unicode reverse²:   ḱṷṓn = LATIN SMALL LETTER K | COMBINING ACUTE ACCENT | LATIN SMALL LETTER U | COMBINING CIRCUMFLEX ACCENT BELOW | LATIN SMALL LETTER O | COMBINING MACRON | COMBINING ACUTE ACCENT | LATIN SMALL LETTER N

'''This uses the unicode string mentioned in the task:'''

ucode = ''.join(chr(int(n, 16))
                 for n in ['61', '73', '20dd', '64', '66', '305'])
say_rev(ucode)

It produces this output {{out}}

Input:              as⃝df̅ = LATIN SMALL LETTER A | LATIN SMALL LETTER S | COMBINING ENCLOSING CIRCLE | LATIN SMALL LETTER D | LATIN SMALL LETTER F | COMBINING OVERLINE
Character reversed: ̅fd⃝sa = COMBINING OVERLINE | LATIN SMALL LETTER F | LATIN SMALL LETTER D | COMBINING ENCLOSING CIRCLE | LATIN SMALL LETTER S | LATIN SMALL LETTER A
Unicode reversed:   f̅d⃝sa = LATIN SMALL LETTER F | COMBINING OVERLINE | LATIN SMALL LETTER D | COMBINING ENCLOSING CIRCLE | LATIN SMALL LETTER S | LATIN SMALL LETTER A
Unicode reverse²:   as⃝df̅ = LATIN SMALL LETTER A | LATIN SMALL LETTER S | COMBINING ENCLOSING CIRCLE | LATIN SMALL LETTER D | LATIN SMALL LETTER F | COMBINING OVERLINE

Qi

It's simplest just to use the common lisp REVERSE function.

(REVERSE "ABCD")

R

{{works with|R|2.8.1}} The following code works with UTF-8 encoded strings too.

revstring <- function(stringtorev) {
   return(
      paste(
           strsplit(stringtorev,"")[[1]][nchar(stringtorev):1]
           ,collapse="")
           )
}

Alternatively (using rev() function):

 revstring <- function(s) paste(rev(strsplit(s,"")[[1]]),collapse="")

revstring("asdf")
revstring("m\u00f8\u00f8se")
Encoding("m\u00f8\u00f8se")   # just to check if on your system it's something
                              # different!

{{out}}

[1] "fdsa"
[1] "esøøm"
[1] "UTF-8"

R can encode strings in Latin1 and UTF-8 (the default may depend on the locale); the Encoding(string) can be used to know if the string is encoded in Latin1 or UTF-8; the encoding can be forced (Encoding(x) <- "latin1"), or we can use iconv to properly translate between encodings whenever possible.

Rascal

import String;
reverse("string")

Racket

As in Scheme:

#lang racket

(define (string-reverse s)
  (list->string (reverse (string->list s))))

(string-reverse "aoeu")

{{out}}

Welcome to DrRacket, version 5.3.3.5--2013-02-20(5eddac74/d) [3m].
Language: racket; memory limit: 512 MB.
"ueoa"
>

RapidQ

print reverse$("This is a test")

Raven

"asdf" reverse

{{out}}

fdsa

REBOL

print reverse "asdf"

Note the string is reversed in place. If you were using it anywhere else, you would find it reversed:

x: "asdf"
print reverse x
print x ; Now reversed.

REBOL/View 2.7.6.3.1 14-Mar-2008 does not handle Unicode strings. This is planned for REBOL 3.

Red

 reverse "asdf"
== "fdsa"

Retro

with strings'
"asdf" reverse puts

REXX

All methods shown below also work with '''NULL''' values.

using REVERSE BIF

/*REXX program to reverse a string  (and show before and after strings).*/

string1 = 'A man, a plan, a canal, Panama!'
string2 = reverse(string1)

say ' original string: '  string1
say ' reversed string: '  string2
                                       /*stick a fork in it, we're done.*/

'''output'''

 original string:  A man, a plan, a canal, Panama!
 reversed string:  !amanaP ,lanac a ,nalp a ,nam A

===using SUBSTR BIF, left to right===

/*REXX program to reverse a string  (and show before and after strings).*/

string1 = 'A man, a plan, a canal, Panama!'
string2 =
                                   do j=1  for length(string1)
                                   string2 = substr(string1,j,1)string2
                                   end   /*j*/
say ' original string: '  string1
say ' reversed string: '  string2
                                       /*stick a fork in it, we're done.*/

'''output''' is identical to the 1^st REXX version.

(Regarding the previous example) Another method of coding an abutment (an implied concatenation) is:

                                   string2 = substr(string1,j,1) || string2
                                                /*───── or ─────*/
                                   string2=substr(string1,j,1)string2

===using SUBSTR BIF, right to left===

/*REXX program to reverse a string  (and show before and after strings).*/

string1 = 'A man, a plan, a canal, Panama!'
string2 =
                                  do j=length(string1)  to 1  by -1
                                  string2 = string2 || substr(string1,j,1)
                                  end   /*j*/
say ' original string: '  string1
say ' reversed string: '  string2
                                       /*stick a fork in it, we're done.*/

'''output''' is identical to the 1^st version.

RLaB

 x = "rosettacode"
rosettacode

// script
rx = "";
for (i in strlen(x):1:-1)
{
  rx = rx + substr(x, i);
}

>> rx
edocattesor

Ring

cStr = "asdf"  cStr2 = ""
for x = len(cStr) to 1 step -1 cStr2 += cStr[x] next
See cStr2  # fdsa

Robotic

. "local1 = Main string"
. "local2 = Temporary string storage"
. "local3 = String length"
set "$local1" to ""
set "$local2 " to ""
set "local3" to 0

input string "String to reverse:"
set "$local1" to "&INPUT&"
set "$local2" to "$local1"
set "local3" to "$local2.length"
loop start
set "$local1.(('local3' - 1) - 'loopcount')" to "$local2.('loopcount')"
loop for "('local3' - 1)"
* "Reversed string: &$local1& (Length: &$local1.length&)"
end

Ruby

str = "asdf"
reversed = str.reverse

or

#encoding: utf-8
"résumé niño".reverse #=> "oñin émusér"

Run BASIC

string$ = "123456789abcdefghijk"
for i = len(string$) to 1 step -1
 print mid$(string$,i,1);
next i

Rust

extern crate unicode_segmentation;
use unicode_segmentation::UnicodeSegmentation;

fn main() {
    let s = "一二三四五六七八九十";
    let s2 = "as⃝df̅";
    let reversed: String = s.chars().rev().collect();
    let reversed2: String = UnicodeSegmentation::graphemes(s2, true)
        .rev().collect();
    println!("{}", reversed);
    println!("{}", reversed2);
}

{{out}} 十九八七六五四三二一

f̅ds⃝a

=={{header|S-lang}}== Here is an 8-bit version: variable sa = "Hello, World", aa = Char_Type[strlen(sa)+1]; init_char_array(aa, sa); array_reverse(aa); % print(aa);

% Unfortunately, strjoin() only joins strings, so we map char() % [sadly named: actually converts char into single-length string] % onto the array:

print( strjoin(array_map(String_Type, &char, aa), "") );

Output: "dlroW ,olleH"

For a Unicode version, we'll create a variant of init_char_array().
Side note: If needed, strbytelen() would give total length of string.

<lang S-lang>define init_unicode_array(a, buf)
{
  variable len = strbytelen(buf), ch, p0 = 0, p1 = 0;
  while (p1 < len) {
    (p1, ch) = strskipchar(buf, p1, 1);
    if (ch < 0) print("oops.");
    a[p0] = ch;
    p0++;
  }
}

variable su = "Σὲ γνωρίζω ἀπὸ τὴν κόψη";
variable au = Int_Type[strlen(su)+1];
init_unicode_array(au, su);
array_reverse(au);
% print(au);
print(strjoin(array_map(String_Type, &char, au), "") );

Output: "ηψόκ νὴτ ὸπἀ ωζίρωνγ ὲΣ"

Note: The init...array() functions include the terminating '\0' chars, but we don't have to filter them out as char(0) produces a zero-length string.

SAS

data _null_;
length a b $11;
a="I am Legend";
b=reverse(a);
put a;
put b;
run;

Sather

class MAIN is
  main is
    s ::= "asdf";
    reversed ::= s.reverse;
    -- current implementation does not handle multibyte encodings correctly
  end;
end;

Scala

Easy way:

"asdf".reverse

Slightly less easy way:

"asdf".foldRight("")((a,b) => b+a)

Unicode-aware, method 1:

def reverse(s: String) = {
  import java.text.{Normalizer,BreakIterator}
  val norm = Normalizer.normalize(s, Normalizer.Form.NFKC) // waffle -> waffle (optional)
  val it = BreakIterator.getCharacterInstance
  it setText norm
  def break(it: BreakIterator, prev: Int, result: List[String] = Nil): List[String] = it.next match {
    case BreakIterator.DONE => result
    case cur => break(it, cur, norm.substring(prev, cur) :: result)
  }
  break(it, it.first).mkString
}

{{out}}

scala> reverse("as⃝df̅")
res0: String = f̅ds⃝a

Unicode-aware, method 2: I can't guarantee it get all the cases, but it does work with combining characters as well as supplementary characters. I did not bother to preserve the order of newline characters, and I didn't even consider directionality beyond just ruling it out.

def reverseString(s: String) = {
  import java.lang.Character._

  val combiningTypes = List(NON_SPACING_MARK, ENCLOSING_MARK, COMBINING_SPACING_MARK)
  def isCombiningCharacter(c: Char) = combiningTypes contains c.getType
  def isCombiningSurrogate(high: Char, low: Char) = combiningTypes contains getType(toCodePoint(high, low))
  def isCombining(l: List[Char]) = l match {
    case List(a, b) => isCombiningSurrogate(a, b)
    case List(a) => isCombiningCharacter(a)
    case Nil => true
    case _ => throw new IllegalArgumentException("isCombining expects a list of up to two characters")
  }

  def cleanSurrogate(l: List[Char]) = l match {
    case List(a, b) if a.isHighSurrogate && b.isLowSurrogate => l
    case List(a, b) if a.isLowSurrogate => Nil
    case List(a, b) => List(a)
    case _ => throw new IllegalArgumentException("cleanSurrogate expects lists of two characters, exactly")
  }

  def splitString(string: String) = (string+" ").iterator sliding 2 map (_.toList) map cleanSurrogate toList

  def recurse(fwd: List[List[Char]], rev: List[Char]): String = fwd match {
    case Nil => rev.mkString
    case c :: rest =>
      val (combining, remaining) = rest span isCombining
      recurse(remaining, c ::: combining.foldLeft(List[Char]())(_ ::: _) ::: rev)
  }
  recurse(splitString(s), Nil)
}

REPL on Windows doesn't handle Unicode, so I'll show the bytes instead:

scala> res71 map ("\\u%04x" format _.toInt)
res80: scala.collection.immutable.IndexedSeq[String] = IndexedSeq(\u0061, \u0073, \u20dd, \u0064, \u0066, \u0305)

scala> reverseString(res71) map ("\\u%04x" format _.toInt)
res81: scala.collection.immutable.IndexedSeq[String] = IndexedSeq(\u0066, \u0305, \u0064, \u0073, \u20dd, \u0061)

Scheme

(define (string-reverse s)
  (list->string (reverse (string->list s))))

(string-reverse "asdf") "fdsa"

Scratch

[[File:ScratchReverseAString.png]]

Sed

#!/bin/sed -f

/../! b

# Reverse a line.  Begin embedding the line between two newlines
s/^.*$/\
&\
/

# Move first character at the end.  The regexp matches until
# there are zero or one characters between the markers
tx
:x
s/\(\n.\)\(.*\)\(.\n\)/\3\2\1/
tx

# Remove the newline markers
s/\n//g

Seed7

Seed7 strings are encoded with UTF-32 therefore no special Unicode solution is necessary

$ include "seed7_05.s7i";

const func string: reverse (in string: stri) is func
  result
    var string: result is "";
  local
    var integer: index is 0;
  begin
    for index range length(stri) downto 1 do
      result &:= stri[index];
    end for;
  end func;

const proc: main is func
  begin
    writeln(reverse("Was it a cat I saw"));
  end func;

{{out}}

was I tac a ti saW

SequenceL

'''Using Library Function:'''

There is a library function to reverse any Sequence. This works for strings since strings are Sequences of characters.

;

main(args(2)) := Sequence::reverse(args[1]);

'''The Library Function:'''

The following is the library implementation of the reverse function.

 : T(1) -> T(1);
reverse(list(1))[i] :=
	let
		range := - ((1 ... size(list)) - (size(list) + 1));
	in
		list[i] foreach i within range;

Sidef

"asdf".reverse;             # fdsa
"résumé niño".reverse;      # oñin émusér

Simula

BEGIN
   TEXT PROCEDURE REV(S); TEXT S;
   BEGIN
       TEXT T;
       INTEGER L,R;
       T :- COPY(S);
       L := 1; R := T.LENGTH;
       WHILE L < R DO
       BEGIN
           CHARACTER CL,CR;
           T.SETPOS(L); CL := T.GETCHAR;
           T.SETPOS(R); CR := T.GETCHAR;
           T.SETPOS(L); T.PUTCHAR(CR);
           T.SETPOS(R); T.PUTCHAR(CL);
           L := L+1;
           R := R-1;
        END;
        REV :- T;
   END REV;

   TEXT INP;
   INP :- "asdf";

   OUTTEXT(INP);      OUTIMAGE;
   OUTTEXT(REV(INP)); OUTIMAGE;
END

{{out}}

asdf
fdsa

Self

In-place reversal:

'asdf' copyMutable reverse

Slate

In-place reversal:

'asdf' reverse

Non-destructive reversal:

'asdf' reversed

Smalltalk

'asdf' reverse

{{works with|Smalltalk/X}} the above does inplace, destructive reverse. It is usually better to use

'asdf' reversed

which returns a new string.

SNOBOL4

ASCII-only

	output = reverse(reverse("reverse"))
end

{{out}}

reverse

Standard ML

val str_reverse = implode o rev o explode;
val string = "asdf";
val reversed = str_reverse string;

Stata

Use '''[https://www.stata.com/help.cgi?f_strreverse strreverse]''' if there are only ASCII characters, and '''[https://www.stata.com/help.cgi?f_ustrreverse ustrreverse]''' if there are Unicode characters in the string.

. scalar s="ARS LONGA VITA BREVIS"
. di strreverse(s)
SIVERB ATIV AGNOL SRA
. scalar s="Ἐν ἀρχῇ ἐποίησεν ὁ θεὸς τὸν οὐρανὸν καὶ τὴν γῆν"
. di ustrreverse(s)
νῆγ νὴτ ὶακ νὸναρὐο νὸτ ςὸεθ ὁ νεσηίοπἐ ῇχρἀ νἘ

Swift

Swift's strings are iterated by Characters, which represent "Unicode grapheme clusters", so reversing it reverses it with combining characters too: {{works with|Swift|2.x+}}

func reverseString(s: String) -> String {
  return String(s.characters.reverse())
}
print(reverseString("asdf"))
print(reverseString("as⃝df̅"))

{{works with|Swift|1.x}}

func reverseString(s: String) -> String {
  return String(reverse(s))
}
println(reverseString("asdf"))
println(reverseString("as⃝df̅"))

{{out}}

fdsa
f̅ds⃝a

Tailspin

templates reverse
  '$:[ $... ] -> $(-1..1:-1)...;' !
end reverse

'asdf' -> reverse -> !OUT::write

'
' -> !OUT::write

'as⃝df̅' -> reverse -> !OUT::write

{{out}}

fdsa
f̅ds⃝a

Tcl

package require Tcl 8.5
string reverse asdf

=={{header|TI-83 BASIC}}== Note: length( and sub( can be found in the catalog.

:Str1
:For(I,1,length(Ans)-1
:sub(Ans,2I,1)+Ans
:End
:sub(Ans,1,I→Str1

Turing

% Reverse a string

var input : string (100)

put "Enter a string to reverse: " ..
get input

var count : int := length(input)
loop
    if count >= 1 then
        put input(count) ..
    else
        exit
    end if
    count := count - 1
end loop

TUSCRIPT

$$ MODE TUSCRIPT
SET input="was it really a big fat cat i saw"
SET reversetext=TURN (input)
PRINT "before: ",input
PRINT "after:  ",reversetext

{{out}}

before: was it really a big fat cat i saw
after:  was i tac taf gib a yllaer ti saw

UNIX Shell

#!/bin/bash
str=abcde

for((i=${#str}-1;i>=0;i--)); do rev="$rev${str:$i:1}"; done

echo $rev

'''or'''

str='i43go1342iu 23iu4o 23iu14i324y 2i13'
rev <<< "$str"
#rev is not built-in function, though is in /usr/bin/rev

Unlambda

Reverse the whole input:

``@c`d``s`|k`@c

Ursala

#import std

#cast %s

example = ~&x 'asdf'

verbose_example = reverse 'asdf'

{{out}}

'fdsa'

=={{Header|Vala}}==

int main (string[] args) {
	if (args.length < 2) {
		stdout.printf ("Please, input a string.\n");
		return 0;
	}
	var str = new StringBuilder ();
	for (var i = 1; i < args.length; i++) {
		str.append (args[i] + " ");
	}
	stdout.printf ("%s\n", str.str.strip ().reverse ());
	return 0;
}

=={{Header|VBA}}== ===Non-recursive version===

Public Function Reverse(aString as String) as String
' returns the reversed string
dim L as integer        'length of string
dim newString as string

newString = ""
L = len(aString)
for i = L to 1 step -1
 newString = newString & mid$(aString, i, 1)
next
Reverse = newString
End Function

Recursive version

Public Function RReverse(aString As String) As String
'returns the reversed string
'do it recursively: cut the string in two, reverse these fragments and put them back together in reverse order
Dim L As Integer    'length of string
Dim M As Integer    'cut point

L = Len(aString)
If L <= 1 Then   'no need to reverse
  RReverse = aString
Else
  M = Int(L / 2)
  RReverse = RReverse(Right$(aString, L - M)) & RReverse(Left$(aString, M))
End If
End Function

Example dialogue

print Reverse("Public Function Reverse(aString As String) As String")
gnirtS sA )gnirtS sA gnirtSa(esreveR noitcnuF cilbuP

print RReverse("Sunday Monday Tuesday Wednesday Thursday Friday Saturday Love")
evoL yadrutaS yadirF yadsruhT yadsendeW yadseuT yadnoM yadnuS

print RReverse(Reverse("I know what you did last summer"))
I know what you did last summer

VBScript

{{works with|Windows Script Host|*}}

WScript.Echo StrReverse("asdf")

Vedit macro language

This routine reads the text from current line, reverses it and stores the reversed string in text register 10:

Reg_Empty(10)
for (BOL; !At_EOL; Char) {
    Reg_Copy_Block(10, CP, CP+1, INSERT)
}

This routine reverses the current line in-place:

BOL
while (!At_EOL) {
    Block_Copy(EOL_pos-1, EOL_pos, DELETE)
}

Visual Basic

{{works with|Visual Basic|6}}

Debug.Print VBA.StrReverse("Visual Basic")

Visual Basic .NET

'''Compiler:''' >= Visual Basic 2012

Includes both a simple version and a version that uses .NET's built-in ability to enumerate strings by grapheme to support combining characters.

Since the windows console may not support Unicode, the program can optionally redirect its output to a file.

#Const REDIRECTOUT = True

Module Program
    Const OUTPATH = "out.txt"

    ReadOnly TestCases As String() = {"asdf", "as⃝df̅", "Les Misérables"}

    ' SIMPLE VERSION
    Function Reverse(s As String) As String
        Dim t = s.ToCharArray()
        Array.Reverse(t)
        Return New String(t)
    End Function

    ' EXTRA CREDIT VERSION
    Function ReverseElements(s As String) As String
        ' In .NET, a text element is series of code units that is displayed as one character, and so reversing the text
        ' elements of the string correctly handles combining character sequences and surrogate pairs.
        Dim elements = Globalization.StringInfo.GetTextElementEnumerator(s)
        Return String.Concat(AsEnumerable(elements).OfType(Of String).Reverse())
    End Function

    ' Wraps an IEnumerator, allowing it to be used as an IEnumerable.
    Iterator Function AsEnumerable(enumerator As IEnumerator) As IEnumerable
        Do While enumerator.MoveNext()
            Yield enumerator.Current
        Loop
    End Function

    Sub Main()
        Const INDENT = "    "

#If REDIRECTOUT Then
        Const OUTPATH = "out.txt"
        Using s = IO.File.Open(OUTPATH, IO.FileMode.Create),
              sw As New IO.StreamWriter(s)
            Console.SetOut(sw)
#Else
        Try
            Console.OutputEncoding = Text.Encoding.ASCII
            Console.OutputEncoding = Text.Encoding.UTF8
            Console.OutputEncoding = Text.Encoding.Unicode
        Catch ex As Exception
            Console.WriteLine("Failed to set console encoding to Unicode." & vbLf)
        End Try
#End If
            For Each c In TestCases
                Console.WriteLine(c)
                Console.WriteLine(INDENT & "SIMPLE:   " & Reverse(c))
                Console.WriteLine(INDENT & "ELEMENTS: " & ReverseElements(c))
                Console.WriteLine()
            Next
#If REDIRECTOUT Then
        End Using
#End If
    End Sub
End Module

{{out|note=copied from Notepad}} Output is presented using non-fixed-width typeface to properly display combining characters.

asdf
    SIMPLE:   fdsa
    ELEMENTS: fdsa

as⃝df̅
    SIMPLE:   ̅fd⃝sa
    ELEMENTS: f̅ds⃝a

Les Misérables
    SIMPLE:   selbaŕesiM seL
    ELEMENTS: selbarésiM seL
```



## Wart


```wart
(rev "asdf")
```


Wart doesn't support Unicode yet.


## Wortel


```wortel
; the @rev operator reverses strings and arrays
@rev "abc" ; returns "cba"
; or the same thing using a pointer expression
!~r "abc"
```



## XPL0


```XPL0
include c:\cxpl\codes;  \intrinsic 'code' declarations
string 0;               \use zero-terminated strings, instead of MSb terminated

func StrLen(Str);       \Return the number of characters in an ASCIIZ string
char Str;
int  I;
for I:= 0 to -1>>1-1 do
        if Str(I) = 0 then return I;

func RevStr(S);         \Reverse the order of the bytes in a string
char S;
int  L, I, T;
[L:= StrLen(S);
for I:= 0 to L/2-1 do
        [T:= S(I);  S(I):= S(L-I-1);  S(L-I-1):= T];
return S;
];

[Text(0, RevStr("a")); CrLf(0);
 Text(0, RevStr("ab")); CrLf(0);
 Text(0, RevStr("abc")); CrLf(0);
 Text(0, RevStr("Able was I ere I saw Elba.")); CrLf(0);
]
```


Output:

```txt

a
ba
cba
.ablE was I ere I saw elbA

```



## Yorick

This only handles ASCII characters. It works by converting a string to an array of char; dropping the last character (which is the null byte); reversing the order of the characters; then converting back to a string.

```yorick
strchar(strchar("asdf")(:-1)(::-1))
```



## zkl

These only handle ASCII characters, no extra credit.

```txt
"this is a test".reverse()
```

Old school ways to do it:

Build by prepending characters, creates n strings:

```txt
"this is a test".reduce(fcn(p,c){c+p})
```

Convert to list, reverse, convert back to string:

```txt
"this is a test".split("").reverse().concat()
```

Write to a byte buffer and convert to string:

```txt
"this is a test".pump(Void,Data().insert.fp(0)).text
```

The ".fp(0)" creates a closure so each character is fed to data.insert(0,c). pump is a method that sends each character to a function to a sink (in this case /dev/null). The output is the result of the last call, which is data.insert which is self/data.


{{omit from|bc|no string operations}}
{{omit from|dc|no string operations}}
{{omit from|Openscad}}
[[Wikipedia::https://en.wikipedia.org/wiki/Comparison_of_programming_languages_%28string_functions%29#reverse]]