Reverse a string: Difference between revisions

 

 

=={{header|0815}}==

This program reverses each line of its input.

!~>& Push a character to the "stack".

<:a:=- Stop reading on newline.

${~ Print the current character until it's 0.

^:p:

 

{{out}}

 

oof

 

=={{header|ACL2}}==

 

ACL2 does not support unicode.

 

=={{header|ActionScript}}==

{

var reversed:String = new String();

{

return string.split('').reverse().join('');

 

=={{header|Ada}}==

procedure Reverse_String is

begin

Put_Line (Reverse_It (Get_Line));

 

 

 

 

=={{header|Aime}}==

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386}}

FOR i TO UPB s OVER 2 DO

CHAR c = s[i];

reverse(text);

print((text, new line))

{{out}}

<pre>

</pre>

 

 

=={{header|AppleScript}}==

 

 

=={{header|AutoHotkey}}==

; <nowiki>"Normal" version:</nowiki>

 

reverse(string)

reversed := A_LoopField . reversed

Return reversed

If (A_IsUnicode){

SLen := StrLen(String) * 2

Return RString

 

=={{header|AutoIt}}==

$mystring="asdf"

$reverse_string = ""

Next

 

 

=={{header|AWK}}==

{

p = ""

BEGIN {

print reverse("edoCattesoR")

;Recursive

{

l = length(s)

BEGIN {

print reverse("edoCattesoR")

 

=={{header|Babel}}==

This example will handle UTF-8 encoded Unicode but doesn't handle combining characters.

*str2ar - this operator converts a UTF-8 encoded string to an array of Unicode codepoints

*ar2ls - this operator converts the array to a linked-list

*ls2lf - this operator undoes the effect of ar2ls

*ar2str - this operator undoes the effect of str2ar

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

b$ = ""

for i = 1 to len(a$)

next i

reverse$ = b$

 

=={{header|Batch File}}==

setlocal enabledelayedexpansion

call :reverse %1 res

set str=%str:~1%

set %2=%chr%!%2!

 

=={{header|BBC BASIC}}==

END

B$ += MID$(A$,C%,1)

NEXT

 

=={{header|Befunge}}==

 

=={{header|Bracmat}}==

= L x

. :?L

| str$!L

)

{{out}}

<pre>άκινηλλΕ</pre>

 

=={{header|Brainf***}}==

<[.<] run all chars backwards and print them

 

just because it looks good we print CRLF

 

=={{header|Brat}}==

 

=={{header|Burlesque}}==

 

"Hello, world!"<-

 

=={{header|C}}==

#include <stdlib.h>

#include <locale.h>

printf("%s => %s\n", su, mb_reverse(su));

return 0;

{{out}}

<pre>abcdef => fedcba

 

{{libheader|GLib}}

gchar *srev (const gchar *s) {

if (g_utf8_validate(s,-1,NULL)) {

printf ("%s\n",srev(u));

return 0;

 

=={{header|C++}}==

#include <algorithm>

 

std::string s;

std::getline(std::cin, s);

std::reverse(s.begin(), s.end()); // modifies s

 

=={{header|Caché ObjectScript}}==

 

<pre>USER>Write $Reverse("Hello, World")

dlroW ,olleH</pre>

 

=={{header|Clipper}}==

Works with versions since 5, because ''LOCAL'' variables and the ''+='' operator was not implemented before.

LOCAL sOut := "", i

FOR i := Len(sIn) TO 1 STEP -1

sOut += Substr(sIn, i, 1)

NEXT

 

=={{header|Clojure}}==

For normal strings, the reverse function can be used to do the bulk of the work. However, it returns a character sequence, which has to be converted back to a string.

=== Supporting combining characters ===

Handling combining characters present a trickier task. We need to protect the relative ordering of the combining character and the character to its left. Thus, before reversing, the characters need to be grouped.

(let [type (Character/getType c)]

;; currently hardcoded to the types taken from the sample string

"Unicode-safe string reverse"

[s]

{{out}}

<pre>

user=>

</pre>

 

=={{header|COBOL}}==

 

=={{header|CoffeeScript}}==

 

=={{header|ColdFusion}}==

You can reverse anything that can be written to the document in hashmarks (i.e. strings, numbers, now( ), etc.).

 

=={{header|Common Lisp}}==

 

=={{header|Component Pascal}}==

BlackBox Component Builder

MODULE BbtReverseString;

IMPORT StdLog;

END Do;

END BbtReverseString.

Execute: ^Q BbtReverseString.Do<br/>

<pre>

'asdf' reversed:> fdsa

</pre>

=={{header|D}}==

import std.range, std.conv;

 

dstring s4 = "hello"d;

assert(s4.dup.reverse == "olleh"d); // simple but inefficient (copies first, then reverses)

 

=={{header|Dart}}==

Since Dart strings are sequences of [http://en.wikipedia.org/wiki/UTF-16 UTF-16] code units, it would not be sufficient to simply reverse the characters in strings, as this would not work with UTF-16 [http://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B10000_to_U.2B10FFFF surrogate pairs] (pairs of UTF-16 code units that represent single characters [http://en.wikipedia.org/wiki/Plane_(Unicode)#Supplementary_Multilingual_Plane outside the Unicode BMP]). However, Dart provides a method to convert strings to sequences of unicode code points (called "runes" in Dart), and these sequences can easily be reversed and used to create new strings, so a string reversal function can be written with a single line of Dart code:

 

 

A more complete example with unit tests would look like this:

 

 

String reverse(String s) => new String.fromCharCodes(s.runes.toList().reversed);

});

});

 

=={{header|Delphi}}==

var

i: integer;

for i := Length(InString) downto 1 do

Result := Result + InString[i];

You could also use this RTL function Introduced in Delphi 6:

{{out}}

 

=={{header|DWScript}}==

See [[Reverse a string#Delphi|Delphi]].

 

=={{header|E}}==

[[Category:E examples needing attention]] <!-- Replacing accum, grapheme clusters -->

def reverse(string) {

return accum "" for i in (0..!(string.size())).descending() { _ + string[i] }

 

 

=={{header|Eiffel}}==

APPLICATION

create

my_string: STRING

-- Used for reversal

{{out}}

<pre>

</pre>

 

 

=={{header|Elixir}}==

Elixir handles Unicode graphemes correctly by default.

IO.puts (String.reverse "asdf")

IO.puts (String.reverse "as⃝df̅")

<pre>

fdsa

f̅ds⃝a

</pre>

 

=={{header|Erlang}}==

Erlang also supports binary strings, which uses its binary format. There is no standard function to reverse a binary sequence, but the following one does the job well enough. It works by changing the endianness (from little to big or the opposite) of the whole sequence, effectively reversing the string.

Size = size(Bin)*8,

<<T:Size/integer-little>> = Bin,

{{out}}

<pre>

<<"olleh">>

</pre>

 

=={{header|Euler Math Toolbox}}==

 

>function strrev (s) := chartostr(fliplr(strtochar(s)))

>strrev("This is a test!")

!tset a si sihT

 

=={{header|Euphoria}}==

 

include std/sequence.e

printf(1, "%s\n", {reverse("abcdef") })

 

=={{header|Ezhil}}==

 

## இந்த நிரல் தரப்படும் சரம் ஒன்றைத் தலைகீழாகத் திருப்பி அச்சிடும்

பதிப்பி "வேறொரு வகையில் திருப்பியுள்ளோம்: " மீண்டும்திருப்புக(அ)

 

 

=={{header|FBSL}}==

A slow way

dim $b = ""

REPEAT len(p1)

return b

End Function

 

A much faster (twice at least) way

dim $b = "", %i

for i = len(p1) DOWNTO 1

next

return b

 

An even faster way using PEEK, POKE, double-calls and quantity-in-hand

FOR DIM x = 1 TO LEN(s) \ 2

PEEK(@s + LEN - x, $1)

RETURN s

end function

 

An even faster way using the DynC (Dynamic C) mode

void rev(char *str)

{

return theString;

}

 

Using DynASM, the Dynamic Assembler mode.

// get length of string

// divide by two

RET

END DYNASM

 

 

 

 

 

=={{header|Forth}}==

2dup c@ swap c@ rot c! swap c! ;

: reverse ( c-addr u -- )

repeat 2drop ;

 

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

 

CHARACTER(80) :: str = "This is a string"

WRITE(*,*) str

 

{{out}}

This is a string

gnirts a si sihT

Another implementation that uses a recursive not-in-place algorithm:

 

implicit none

end function reverse

 

{{out}}

<pre>no devil lived on

no devil lived on</pre>

 

=={{header|Frink}}==

The built-in <CODE>reverse</CODE> function reverses a string or the elements of a list.

 

=={{header|GAP}}==

 

=={{header|Gema}}==

Reverse each line in the input stream. Using built in function:

Not using built in function (recursively apply substring to same rule):

 

=={{header|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.

 

import (

r = reversePreservingCombiningCharacters(s)

fmt.Println("combining characters:", []rune(r), r)

{{out}}

<pre>

 

=={{header|Groovy}}==

{{out}}

<pre>.ablE was I ere' ,I saw elbA</pre>

 

 

=={{header|Harbour}}==

 

LOCAL cOut := "", i

NEXT

 

 

=={{header|Haskell}}==

This function as defined in the Haskell Prelude.

===Supporting combining characters===

import Data.List (groupBy)

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

 

=={{header|HicEst}}==

 

L = LEN( string )

ENDDO

 

 

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

s := \arglist[1] | "asdf"

write(s," <-> ", reverse(s)) # reverse is built-in

 

=={{header|Io}}==

 

=={{header|J}}==

Reverse (<tt>|.</tt>) reverses a list of items (of any shape or type).

Extra credit:

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

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.

 

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.

 

=={{header|Java}}==

 

=={{header|JavaScript}}==

 

=={{header|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.

 

 

=={{header|Julia}}==

 

=={{header|L++}}==

(main

(decl std::string s)

(std::getline std::cin s)

(std::reverse (s.begin) (s.end))

 

=={{header|LabVIEW}}==

{{VI solution|LabVIEW_Reverse_a_string.png}}

 

=={{header|Lang5}}==

 

=={{header|Lasso}}==

 

===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.

with i in #input->values

do #output->insertFirst(#i)

 

=={{header|Liberty BASIC}}==

print input$

print ReversedStr$( input$)

ReversedStr$ =ReversedStr$ +mid$( in$, i, 1)

next i

 

=={{header|LiveCode}}==

repeat with i = length(S) down to 1

put char i of S after R

end repeat

return R

 

=={{header|Logo}}==

REVERSE works on both words and lists.

 

=={{header|Lua}}==

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

 

=={{header|M4}}==

 

=={{header|Maple}}==

 

 

=={{header|MATLAB}}==

 

Sample Usage:

'Grabbed her hand out the club and I said let''s skate.'])

 

ans =

 

 

=={{header|Maxima}}==

 

 

=={{header|MAXScript}}==

(

local reversed = ""

for i in s.count to 1 by -1 do reversed += s[i]

reversed

 

=={{header|Mirah}}==

StringBuilder.new(s).reverse

end

 

 

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

 

IMPORT IO, Text;

BEGIN

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

{{out}}

<pre>

 

=={{header|MUMPS}}==

;Take in a string and reverse it using the built in function $REVERSE

NEW S

READ:30 "Enter a string: ",S

WRITE !,$REVERSE(S)

{{out}}

<pre>

Enter a string: Hello, World!

!dlroW ,olleH

</pre>

 

===Supporting Combining Characters===

Compile with:<pre>ncc -reference:System.Windows.Forms reverse.n</pre>

using System.Globalization;

using System.Windows.Forms;

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.

{

mutable output = [];

output ::= c.ToString();

Concat("", output)

 

=={{header|NetRexx}}==

 

options replace format comments java crossref savelog symbols nobinary

say sihTesrever

 

{{out}}

<pre>

fdsa

</pre>

 

=={{header|Nial}}==

 

 

 

 

 

 

 

 

 

=={{header|Objeck}}==

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

 

=={{header|Objective-C}}==

This extends the <code>NSString</code> object adding a <code>reverseString</code> class method.

 

@interface NSString (Extended)

return rtr;

}

Usage example:

{

@autoreleasepool {

}

return 0;

===Supporting combining characters===

Extra credit

 

@interface NSString (Extended)

return ostr;

}

Usage example:

{

@autoreleasepool {

}

return 0;

 

=={{header|OCaml}}==

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

for i = 0 to last / 2 do

let j = last - i in

if List.length list = String.length strin

then String.concat "" list

 

will return "!dlroW olleH"

 

=={{header|Octave}}==

 

=={{header|OpenEdge/Progress}}==

INPUT i_c AS CHARACTER

):

END FUNCTION.

 

 

=={{header|OxygenBasic}}==

 

'8 BIT CHARACTERS

'

print s

 

==OxygenBasic x86 Assembler==

32 bit code, 8-bit characters:

 

string s="qwertyuiop"

 

print s

 

=={{header|Oz}}==

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

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

fun {DoReverse Xs Ys}

case Xs of nil then Ys

in

fun {Reverse Xs} {DoReverse Xs nil} end

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

 

=={{header|PARI/GP}}==

 

=={{header|Pascal}}==

 

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).

procedure reverse(s: array[min .. max: integer] of char, var result: array[min1 .. max1: integer] of char);

var

for i := 0 to len-1 do

result[min1 + len-1 - i] := s[min + i]

function revstr(my_s:string):string;

var out_s:string;

out_s:=out_s+my_s[ls-i+1];

revstr:=out_s;

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

var i:integer;

var tmp:char;

reverse:=s;

end;

 

=={{header|Perl}}==

 

 

 

=={{header|PHP}}==

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

 

=={{header|PicoLisp}}==

{{out}}

<pre>-> "ßÜÖÄüöä"</pre>

 

=={{header|PL/I}}==

 

=={{header|Pop11}}==

lvars i, l = length(s);

for i from l by -1 to 1 do

endfor;

consstring(l);

 

=={{header|PostScript}}==

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

/str exch def

/temp str 0 get def

}repeat

str pstack

[3 2 1]

 

(Hello World) reverse % input

 

=={{header|PowerShell}}==

Test string

Creating a character array from the end to the string's start and join it together into a string again.

{{works with|PowerShell|1}}

{{works with|PowerShell|2}}

{{works with|PowerShell|2}}

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.Length),

{{works with|PowerShell|2}}

('(.)' * $s.Length),

 

=={{header|Prolog}}==

{{works with|SWI Prolog}}

L = [100,99,98,97],

accRev([], A, A).

 

 

=={{header|PureBasic}}==

 

=={{header|Python}}==

===Optimized for user input===

===Already known string===

 

 

 

def ureverse(ustring):

groupedchars = []

uchar = list(ustring)

while uchar:

groupedchars[-1] += uchar.pop(0)

else:

# Grouped reversal

groupedchars = groupedchars[::-1]

return ''.join(groupedchars)

 

if __name__ == '__main__':

 

=={{header|Qi}}==

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

 

=={{header|R}}==

{{works with|R|2.8.1}}

The following code works with UTF-8 encoded strings too.

return(

paste(

,collapse="")

)

 

Alternatively (using rev() function):

 

 

revstring("m\u00f8\u00f8se")

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

{{out}}

<pre>

</pre>

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

 

=={{header|Racket}}==

As in Scheme:

 

 

(define (string-reverse s)

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

 

 

{{out}}

"ueoa"

> </pre>

 

=={{header|Raven}}==

{{out}}

<pre>fdsa</pre>

=={{header|REBOL}}==

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

print reverse x

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

 

=={{header|Retro}}==

 

=={{header|REXX}}==

 

string1 = 'A man, a plan, a canal, Panama!'

say ' original string: ' string1

say ' reversed string: ' string2

'''output'''

<pre>

</pre>

 

 

string1 = 'A man, a plan, a canal, Panama!'

say ' original string: ' string1

say ' reversed string: ' string2

<br><br>(Regarding the previous example) &nbsp; Another method of coding an abutment (an implied concatenation) is:

/*───── or ─────*/

 

 

string1 = 'A man, a plan, a canal, Panama!'

say ' original string: ' string1

say ' reversed string: ' string2

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

<br><br>

 

=={{header|RLaB}}==

rosettacode

 

 

>> rx

 

=={{header|Ruby}}==

 

=={{header|Run BASIC}}==

for i = len(string$) to 1 step -1

print mid$(string$,i,1);

 

=={{header|Rust}}==

 

=={{header|SAS}}==

length a b $11;

a="I am Legend";

put a;

put b;

 

=={{header|Sather}}==

main is

s ::= "asdf";

-- current implementation does not handle multibyte encodings correctly

end;

 

=={{header|Scala}}==

Easy way:

 

Slightly less easy way:

 

import java.lang.Character._

}

recurse(splitString(s), Nil)

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

<pre>

 

=={{header|Scheme}}==

 

> (string-reverse "asdf")

 

=={{header|Sed}}==

 

/../! b

 

# Remove the newline markers

 

=={{header|Seed7}}==

 

result

var string: result is "";

const proc: main is func

begin

<pre>

was I tac a ti saW

</pre>

 

=={{header|Sidef}}==

 

=={{header|Slate}}==

In-place reversal:

Non-destructive reversal:

 

=={{header|Smalltalk}}==

{{works with|Smalltalk/X}}

the above does inplace, destructive reverse. It is usually better to use

which returns a new string.

 

=={{header|SNOBOL4}}==

ASCII-only

<pre>reverse</pre>

 

=={{header|Standard ML}}==

val string = "asdf";

 

=={{header|Swift}}==

Swift's strings are iterated by <code>Character</code>s, which represent "Unicode grapheme clusters", so reversing it reverses it with combining characters too:

}

println(reverseString("asdf"))