Reverse a string: Difference between revisions
m
→{{header|Oberon}}: Fixed language name
m (→{{header|Tailspin}}: syntax update) |
m (→{{header|Oberon}}: Fixed language name) |
||
(127 intermediate revisions by 64 users not shown) | |||
Line 17:
=={{header|0815}}==
This program reverses each line of its input.
<
!~>& Push a character to the "stack".
<:a:=- Stop reading on newline.
Line 26:
${~ Print the current character until it's 0.
^:p:
#:r: Read again.</
{{out}}
<
oof
rab</
=={{header|11l}}==
<syntaxhighlight lang="11l">reversed(string)</syntaxhighlight>
=={{header|360 Assembly}}==
For maximum compatibility, this program uses only the basic instruction set (S/360)
and an ASSIST macro (XPRNT) to keep the code as short as possible.
<
REVERSE CSECT
USING REVERSE,R13 base register
Line 65 ⟶ 68:
C DC CL12'edoC attesoR'
TMP DS CL12
END REVERSE</
{{out}}
<pre>
Rosetta Code
</pre>
This second example uses MVCIN introduced in S/370 architecture.
<syntaxhighlight lang="360asm">* Reverse a string 25/04/2020
REVERSEI CSECT
USING REVERSEI,R13 base register
B 72(R15) skip savearea
DC 17F'0' savearea
STM R14,R12,12(R13) prolog
ST R13,4(R15) "
ST R15,8(R13) "
LR R13,R15 "
MVCIN BB,AA+L'AA-1
XPRNT BB,L'BB print bb
L R13,4(0,R13) epilog
LM R14,R12,12(R13) "
XR R15,R15 "
BR R14 exit
AA DC CL12'edoC attesoR' a
BB DS CL(L'AA) b
REGEQU
END REVERSEI</syntaxhighlight>
{{out}}
<pre>
Rosetta Code
</pre>
=={{header|8080 Assembly}}==
This is a routine that reverses a string with a terminator in place.
Back when the 8080 was commonly used, there wasn't really a set standard about how to store strings.
Zero-terminated strings were already in use by the C language (and therefore, programs written in it).
CP/M, on the other hand, used <code>$</code> as a string terminator. (Later versions would even allow
the programmer to set it himself with a system call!) Therefore, to allow for some flexibility,
this routine also allows you to set it yourself, using the A register.
There were other ways of representing strings, like setting the high bit of the last character to mark
the end (saves a byte per string, but halves the character set size), or prepending the length
(making it unnecessary to scan through the string to find the end, but capping string size at
255 bytes), or even storing tuples of lengths and pointers (easy for a garbage collector to manage).
These are not supported, as they would be completely different routines, though the <code>arrayrev</code>
entry point will reverse a byte array if you already have its start and end.
Unicode is not supported either. While it wouldn't be impossible to do, I think writing a full UTF-8
implementation is beyond the scope of the task.
<syntaxhighlight lang="8080asm"> org 100h
jmp test
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Reverse a string under HL in place
;; strrev0: reverse a zero-terminated string
;; strrev: reverse a string terminated by the value in A
;; arrayrev: reverse bytes starting at DE and ending at HL
;; Destroys a, b, d, e, h, l registers.
strrev0: xra a ; Zero A
strrev: mov d,h ; Copy string begin to DE
mov e,l
dcx h
strrev_end: inx h ; Find string end in HL
cmp m
jnz strrev_end
dcx h ; Point HL to last character
arrayrev: mov a,h ; If HL<DE, we're done
cmp d
rc
mov a,l
cmp e
rc
ldax d ; Get low character in string
mov b,m ; Get high character in string
mov m,a ; Swap them
mov a,b
stax d
inx d ; Move the low pointer up,
dcx h ; and the high pointer down
jmp arrayrev
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Test code (CP/M): ask the user for a string, and reverse it
prompt: db " :gnirts a retne esaelP$"
bufdef: db 127, 0
buf: ds 128 ; one extra byte that will remain 0
newline: lxi d,newline_str
mvi c,9
jmp 5
newline_str: db 13, 10, "$"
test: ;; Reverse and output the prompt
mvi a,'$' ; CP/M string is $-terminated
lxi h,prompt ; Reverse the string
call strrev
lxi d,prompt ; Output the string
mvi c,9
call 5
;; Get input and reverse it
lxi d,bufdef
mvi c,10
call 5
call newline
lxi h,buf
call strrev0 ; 0-terminated due to buffer definition
;; Output reversed input
lxi h,buf
loop: mov e,m
xra a
ora e
rz ; Stop when done
mvi c,2
push h
call 5
pop h
inx h
jmp loop</syntaxhighlight>
=={{header|8th}}==
In 8th strings are UTF-8 and the language retains characters per-se:
<
"abc" s:rev
</syntaxhighlight>
{{out}}
<tt>"cba"</tt>
=={{header|ACL2}}==
<
ACL2 does not support unicode.
=={{header|Action!}}==
<syntaxhighlight lang="action!">PROC Reverse(CHAR ARRAY src,dst)
BYTE i,j
i=1 j=src(0) dst(0)=j
WHILE j>0
DO
dst(j)=src(i)
i==+1 j==-1
OD
RETURN
PROC Test(CHAR ARRAY src)
CHAR ARRAY dst(40)
Reverse(src,dst)
PrintF("'%S' -> '%S'%E",src,dst)
RETURN
PROC Main()
Test("Hello World!")
Test("123456789")
Test("!noitcA iratA")
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Reverse_a_string.png Screenshot from Atari 8-bit computer]
<pre>
'Hello World!' -> '!dlroW olleH'
'123456789' -> '987654321'
'!noitcA iratA' -> 'Atari Action!'
</pre>
=={{header|ActionScript}}==
<
{
var reversed:String = new String();
Line 97 ⟶ 253:
{
return string.split('').reverse().join('');
}</
=={{header|Ada}}==
<
procedure Reverse_String is
Line 113 ⟶ 269:
begin
Put_Line (Reverse_It (Get_Line));
end Reverse_String;</
=={{header|Agda}}==
Using the Agda standard library, version
<syntaxhighlight lang="agda">
module ReverseString where
open import Data.String using (String ; fromList ; toList)
open import Data.List using (reverse)
</syntaxhighlight>
=={{header|Aime}}==
<
=={{header|ALGOL 68}}==
Line 133 ⟶ 290:
{{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];
Line 145 ⟶ 302:
reverse(text);
print((text, new line))
)</
{{out}}
<pre>
Line 151 ⟶ 308:
</pre>
=={{header|Amazing Hopper}}==
<syntaxhighlight lang="amazing hopper">
#include <hopper.h>
main:
s="mañana será otro día"
reverse(s),strtoutf8, println
{0}return
</syntaxhighlight>
{{out}}
<pre>
aíd orto áres anañam
</pre>
=={{header|Apex}}==
<
String str = 'Hello World!';
str = str.reverse();
system.debug(str);
</syntaxhighlight>
==
<
fdsa</
=={{header|AppleScript}}==
{{works with |AppleScript| 2.0 or newer.}}
<
on reverseString(str)
reverse of characters of str as string
end reverseString</
'''NB.''' Since coercing lists to string involves the interpolation of the current value of AppleScript's text item delimiters between the list items, it's considered best practice to set the delimiters ''explicitly'' to their default value of <code>{""}</code> (or just <code>""</code>) before doing an operation like this, in case they've been set to something else elsewhere in the script:
<syntaxhighlight lang="applescript">reverseString("Hello World!")
on reverseString(str)
set astid to AppleScript's text item delimiters
set AppleScript's text item delimiters to ""
set reversedString to reverse of characters of str as text
set AppleScript's text item delimiters to astid
return reversedString
end reverseString</syntaxhighlight>
----
Or, if we want a polymorphic '''reverse()''' for both strings and lists, we can define it either in terms of a generic fold/reduce, or using the built-in method for lists:
<
-- reverse1 :: [a] -> [a]
Line 250 ⟶ 431:
end script
end if
end mReturn</
{{Out}}
<
{"! ereht olleH", {5, 4, 3, 2, 1}}}</
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">str: "Hello World"
print reverse str</syntaxhighlight>
{{out}}
<pre>dlroW olleH</pre>
=={{header|AutoHotkey}}==
; <nowiki>"Normal" version:</nowiki>
<
reverse(string)
Line 330 ⟶ 455:
reversed := A_LoopField . reversed
Return reversed
}</
; <nowiki>A ''much'' slower version:</nowiki>
<
If (A_IsUnicode){
SLen := StrLen(String) * 2
Line 350 ⟶ 475:
Return RString
}</
=={{header|AutoIt}}==
<
$mystring="asdf"
$reverse_string = ""
Line 364 ⟶ 489:
Next
MsgBox(0, "Reversed string is:", $reverse_string)</
=={{header|Avail}}==
<syntaxhighlight lang="avail">"asfd" reversed</syntaxhighlight>
=={{header|AWK}}==
<
{
p = ""
Line 376 ⟶ 504:
BEGIN {
print reverse("edoCattesoR")
}</
;Recursive
<
{
l = length(s)
Line 387 ⟶ 515:
BEGIN {
print reverse("edoCattesoR")
}</
;using split, then joining in front:
<
function rev(s, i,len,a,r) {
Line 402 ⟶ 530:
print s, "<-->", rev(s)
}
</syntaxhighlight>
{{out}}
Rosetta <--> attesoR
Line 408 ⟶ 536:
=={{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
Line 416 ⟶ 544:
=={{header|BaCon}}==
<
s$ = "asdf"
PRINT REVERSE$(s$)</
Unicode preservation works in BaCon 3.6 and higher.
=={{header|BASIC}}==
==={{header|Applesoft BASIC}}===
<syntaxhighlight lang="applesoftbasic">10 A$ = "THE FIVE BOXING WIZARDS JUMP QUICKLY"
20 GOSUB 100REVERSE
30 PRINT R$
40 END
100 REMREVERSE A$
110 R$ = ""
120 FOR I = 1 TO LEN(A$)
130 R$ = MID$(A$, I, 1) + R$
140 NEXT I
150 RETURN</syntaxhighlight>
==={{header|BASIC256}}===
<syntaxhighlight lang="vb">s = "asdf"
print "'"; s; "' reversed is '"; reverse(s); "'"
end
function reverse(a)
b = ""
for i = 1 to length(a)
b = mid(a, i, 1) + b
next i
return b
end function</syntaxhighlight>
{{out}}
<pre>'asdf' reversed is 'fdsa'</pre>
==={{header|Commodore BASIC}}===
{{works with|Commodore BASIC|3.5,7.0}}
Commodore BASIC 3.5 turned MID$ into an lvalue function, and assigning a string of the same length to MID$ replaces the characters instead of allocating a new string, so the reversal can be done in-place:
<syntaxhighlight lang="basic">
100 INPUT "STRING";S$
110 FOR I=1 TO INT(LEN(S$)/2)
120 : J=LEN(S$)+1-I
130 : T$=MID$(S$,I,1)
140 : MID$(S$,I,1) = MID$(S$,J,1)
150 : MID$(S$,J,1) = T$
160 NEXT I
170 PRINT S$</syntaxhighlight>
{{Out}}
<pre>STRING? THIS IS A TEST
TSET A SI SIHT
READY.</pre>
==={{header|IS-BASIC}}===
<
120 LET REV$=""
130 FOR I=LEN(TX$) TO 1 STEP-1
140 LET REV$=REV$&TX$(I)
150 NEXT
160 PRINT REV$</
==={{header|QuickBASIC}}===
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
<syntaxhighlight lang="qbasic">function reverse$(a$)
b$ = ""
for i = 1 to len(a$)
b$ = mid$(a$, i, 1) + b$
next i
reverse$ = b$
end function</syntaxhighlight>
==={{header|Sinclair ZX81 BASIC}}===
<
20 LET T$=""
30 FOR I=LEN S$ TO 1 STEP -1
40 LET T$=T$+S$(I)
50 NEXT I
60 PRINT T$</
==={{header|True BASIC}}===
<syntaxhighlight lang="qbasic">FUNCTION reverse$(a$)
LET b$ = ""
FOR i = 1 TO LEN(a$)
LET b$ = (a$)[i:i+1-1] & b$
NEXT i
LET reverse$ = b$
END FUNCTION
LET s$ = "asdf"
PRINT "'"; s$; "' reversed is '"; reverse$(s$); "'"
END</syntaxhighlight>
{{out}}
<pre>'asdf' reversed is 'fdsa'</pre>
==={{header|XBasic}}===
{{works with|Windows XBasic}}
<syntaxhighlight lang="qbasic">PROGRAM "progname"
VERSION "0.0000"
DECLARE FUNCTION Entry ()
DECLARE FUNCTION reverse$ (a$)
FUNCTION Entry ()
s$ = "asdf"
PRINT "'"; s$; "' reversed is '"; reverse$(s$); "'"
END FUNCTION
FUNCTION reverse$ (a$)
b$ = ""
FOR i = 1 TO LEN(a$)
b$ = MID$(a$, i, 1) + b$
NEXT i
RETURN b$
END FUNCTION
END PROGRAM</syntaxhighlight>
{{out}}
<pre>'asdf' reversed is 'fdsa'</pre>
==={{header|Yabasic}}===
<syntaxhighlight lang="vb">s$ = "asdf"
print "'", s$, "' reversed is '", reverse$(s$), "'"
end
sub reverse$(a$)
b$ = ""
for i = 1 to len(a$)
b$ = mid$(a$, i, 1) + b$
next i
return b$
end sub</syntaxhighlight>
{{out}}
<pre>'asdf' reversed is 'fdsa'</pre>
=={{header|Batch File}}==
<
setlocal enabledelayedexpansion
call :reverse %1 res
Line 465 ⟶ 697:
set str=%str:~1%
set %2=%chr%!%2!
goto loop</
=={{header|BBC BASIC}}==
<
END
Line 476 ⟶ 708:
B$ += MID$(A$,C%,1)
NEXT
= B$</
=={{header|Beef}}==
Beef does not have a built-in Reverse method for strings, however one can 'extend' the builtin String class to provide a Reverse function.
<syntaxhighlight lang="csharp">using System;
namespace System
{
extension String
{
public void Reverse()
{
int i = 0;
int j = mLength - 1;
while (i < j)
{
Swap!(Ptr[i++], Ptr[j--]);
}
}
}
}
namespace StringReverse
{
class Program
{
static void Main()
{
String s = scope .("abcdef");
s.Reverse();
Console.WriteLine(s);
}
}
}
</syntaxhighlight>
=={{header|Befunge}}==
Reads a line from stdin and write the reverse to stdout. Can be made to repeat indefinitely by removing the final <tt>@</tt> command.
<
=={{header|Binary Lambda Calculus}}==
This 9 byte program, featured on https://www.ioccc.org/2012/tromp/hint.html, reverses its input in byte-oriented BLC:
<pre>16 46 80 17 3e f0 b7 b0 40</pre>
=={{header|BQN}}==
BQN has a reverse builtin, given as <code>⌽</code>.
<syntaxhighlight lang="bqn"> ⌽"racecar"
"racecar"</syntaxhighlight>
=={{header|Bracmat}}==
<
= L x
. :?L
Line 498 ⟶ 776:
| str$!L
)
& out$reverse$Ελληνικά</
{{out}}
<pre>άκινηλλΕ</pre>
=={{header|Brainf***}}==
<
Another solution:
<syntaxhighlight lang="bf">,----- ----- [+++++ +++++ > , ----- -----] If a newline is hit counter will be zero and input loop ends
<[.<] run all chars backwards and print them
just because it looks good we print CRLF
+++++ +++++ +++ . --- .</
=={{header|Brat}}==
<
=={{header|Burlesque}}==
<
"Hello, world!"<-
</syntaxhighlight>
=={{header|C}}==
<
#include <stdlib.h>
#include <locale.h>
Line 588 ⟶ 865:
printf("%s => %s\n", su, mb_reverse(su));
return 0;
}</
{{out}}
<pre>abcdef => fedcba
Line 594 ⟶ 871:
{{libheader|GLib}}
<
gchar *srev (const gchar *s) {
if (g_utf8_validate(s,-1,NULL)) {
Line 606 ⟶ 883:
printf ("%s\n",srev(u));
return 0;
}</
=={{header|C sharp}}==
C# does not have a built-in Reverse method for strings, and cannot reverse them in place because they are immutable. One way to implement this is to convert the string to an array of characters, reverse that, and return a new string from the reversed array:
<
{
char[] inputChars = input.ToCharArray();
Array.Reverse(inputChars);
return new string(inputChars);
}</
As of .Net 3.5 the LINQ-to-objects allows the Reverse() extension method to be called on a string, since String implements the IEnumerable<char> interface. Because of this, the return type of Reverse is IEnumerable<char>. Fortunately, LINQ also provides the ToArray extension method, which can be used in conjunction with the constructor of string that accepts a char array:
<
// ...
Line 638 ⟶ 901:
return new string(input.Reverse().ToArray());
// ...</
'''Version supporting combining characters:'''
System.Globalization.StringInfo provides a means of separating a string into individual graphemes.
<
{
// In .NET, a text element is series of code units that is displayed as one character, and so reversing the text
Line 656 ⟶ 919:
while (enumerator.MoveNext())
yield return enumerator.Current;
}</
=={{header|C++}}==
<syntaxhighlight lang="cpp">#include <string>
#include <iostream>
#include <algorithm>
int main() {
std::string s;
std::getline(std::cin, s);
std::reverse(s.begin(), s.end()); // modifies s
std::cout << s << '\n';
}</syntaxhighlight>
=={{header|Caché ObjectScript}}==
Line 663 ⟶ 938:
dlroW ,olleH</pre>
=={{header|Ceylon}}==
<syntaxhighlight lang="ceylon">
shared void run() {
Line 680 ⟶ 954:
}
}
</syntaxhighlight>
=={{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
RETURN sOut</
=={{header|Clojure}}==
=== A Simple implementation with the magic of "conj" function ===
<syntaxhighlight lang="lisp">
(defn reverse-string [s]
"Returns a string with all characters in reverse"
(apply str (reduce conj '() s)))
</syntaxhighlight>
=== Other alternatives (resorting to the "reverse" function in the standard library)===
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.
a) <
b) <
=== 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
Line 719 ⟶ 1,003:
"Unicode-safe string reverse"
[s]
(apply str (apply concat (reverse (group s)))))</
{{out}}
<pre>
Line 730 ⟶ 1,014:
user=>
</pre>
=={{header|CLU}}==
<syntaxhighlight lang="clu">reverse = proc (s: string) returns (string)
rslt: array[char] := array[char]$predict(1,string$size(s))
for c: char in string$chars(s) do
array[char]$addl(rslt,c)
end
return(string$ac2s(rslt))
end reverse
start_up = proc ()
po: stream := stream$primary_output()
stream$putl(po, reverse("!dlrow ,olleH"))
end start_up</syntaxhighlight>
{{out}}
<pre>Hello, world!</pre>
=={{header|COBOL}}==
<syntaxhighlight lang
=={{header|CoffeeScript}}==
<
=={{header|ColdFusion}}==
You can reverse anything that can be written to the document in hashmarks (i.e. strings, numbers, now( ), etc.).
<
<cfset myString = reverse( myString ) /></
=={{header|Common Lisp}}==
<syntaxhighlight lang
=={{header|Component Pascal}}==
BlackBox Component Builder
<
MODULE BbtReverseString;
IMPORT StdLog;
Line 774 ⟶ 1,074:
END Do;
END BbtReverseString.
</syntaxhighlight>
Execute: ^Q BbtReverseString.Do<br/>
{{Out}}
Line 780 ⟶ 1,080:
'asdf' reversed:> fdsa
</pre>
=={{header|Cowgol}}==
<syntaxhighlight lang="cowgol">include "cowgol.coh";
include "strings.coh";
# Reverse a string in place
sub StrRev(s: [uint8]): (r: [uint8]) is
r := s;
var e := s;
while [e] != 0 loop
e := @next e;
end loop;
e := @prev e;
while e > s loop
var c := [s];
[s] := [e];
[e] := c;
s := @next s;
e := @prev e;
end loop;
end sub;
# Test
var buf: uint8[32];
var str: [uint8] := "\nesreveR";
CopyString(str, &buf[0]);
print(StrRev(&buf[0]));</syntaxhighlight>
{{out}}
<pre>Reverse</pre>
=={{header|Crystal}}==
<
strings = ["asdf", "as⃝df̅"]
strings.each do |s|
puts "#{s} -> #{s.reverse}"
end</
{{out}}
Line 796 ⟶ 1,127:
=={{header|D}}==
<
import std.range, std.conv;
Line 811 ⟶ 1,142:
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);
Line 844 ⟶ 1,167:
});
});
}</
=={{header|DBL}}==
<syntaxhighlight lang="dbl">K=
STR_OUT=
FOR J=%TRIM(STR_IN) STEP -1 UNTIL 1
DO BEGIN
INCR K
STR_OUT(K:1)=STR_IN(J:1)
END
</syntaxhighlight>
=={{header|Dc}}==
Reversing "Hello world!" which is "22405534230753963835153736737" in Dc's numerical string representaion.<br>
Due to using "~" this example needs GNU Dc or OpenBSD Dc.
<syntaxhighlight lang="dc">22405534230753963835153736737 [ 256 ~ d SS 0<F LS SR 1+ ] d sF x 1 - [ 1 - d 0<F 256 * LR + ] d sF x P</syntaxhighlight>
<pre>
!dlrow olleH
</pre>
=={{header|Delphi}}==
<
var
i: integer;
Line 853 ⟶ 1,196:
for i := Length(InString) downto 1 do
Result := Result + InString[i];
end;</
You could also use this RTL function Introduced in Delphi 6:
<syntaxhighlight lang
Another alternative.
<syntaxhighlight lang="delphi">
function Reverse(const s: string): string;
var
i, aLength, ahalfLength: Integer;
c: Char;
begin
Result := s;
aLength := Length(s);
ahalfLength := aLength div 2;
if aLength > 1 then
for i := 1 to ahalfLength do
begin
c := result[i];
result[i] := result[aLength - i + 1];
result[aLength - i + 1] := c;
end;
end;</syntaxhighlight>
All versions has the same perfomance, then StrUtils is recomended.
=={{header|Draco}}==
<syntaxhighlight lang="draco">/* Reverse string in place */
proc nonrec reverse(*char s) void:
*char e;
char t;
e := s;
while e* /= '\e' do
e := e + 1
od;
while
e := e - 1;
s < e
do
t := e*;
e* := s*;
s* := t;
s := s + 1
od
corp
proc nonrec main() void:
*char testString = "!dlrow ,olleH";
reverse(testString);
writeln(testString)
corp</syntaxhighlight>
{{out}}
<pre>
=={{header|dt}}==
<syntaxhighlight lang="dt">"asdf" rev</syntaxhighlight>
=={{header|DWScript}}==
Line 866 ⟶ 1,256:
=={{header|Dyalect}}==
<
func String.
var cs = []
for n in 1..len {
cs.
}
String(values: cs)
}
str.Reverse()</syntaxhighlight>
=={{header|Déjà Vu}}==
<syntaxhighlight lang="dejavu">!print concat chars "Hello"</syntaxhighlight>
{{out}}
<pre>olleH</pre>
=={{header|EasyLang}}==
<syntaxhighlight lang="easylang">
func$ reverse s$ .
a$[] = strchars s$
for i = 1 to len a$[] div 2
swap a$[i] a$[len a$[] - i + 1]
.
return strjoin a$[]
.
print reverse "hello"
</syntaxhighlight>
=={{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|EchoLisp}}==
<
(define (string-reverse string)
(list->string (reverse (string->list string))))
Line 895 ⟶ 1,303:
(string-reverse "un roc lamina l animal cornu")
→ unroc lamina l animal cor nu
</syntaxhighlight>
=={{header|
<syntaxhighlight lang="egl">function reverse( str string ) returns( string )
result string;
for ( i int from StrLib.characterLen( str ) to 1 decrement by 1 )
result ::= str[i:i];
end
return( result );
end</syntaxhighlight>
=={{header|Eiffel}}==
<
APPLICATION
create
Line 919 ⟶ 1,329:
my_string: STRING
-- Used for reversal
end</
{{out}}
<pre>
Line 925 ⟶ 1,335:
</pre>
=={{header|Ela}}==
<
where len = length str
rev 0 str = ""
Line 940 ⟶ 1,342:
where nn = n - 1
reverse_string "Hello"</
{{out}}<pre>"olleH"</pre>
Line 946 ⟶ 1,348:
Another approach is to covert a string to a list, reverse a list and then convert it back to a string:
<
fromList <| reverse <| toList "Hello" ::: String</
=={{header|Elena}}==
ELENA 4.x:
<
import extensions;
import extensions'text;
Line 964 ⟶ 1,366:
{
console.printLine("Hello World".reversedLiteral())
}</
{{out}}
<pre>
Line 972 ⟶ 1,374:
=={{header|Elixir}}==
Elixir handles Unicode graphemes correctly by default.
<
IO.puts (String.reverse "asdf")
IO.puts (String.reverse "as⃝df̅")
</syntaxhighlight>
{{Out}}
<pre>
Line 981 ⟶ 1,383:
f̅ds⃝a
</pre>
=={{header|Elm}}==
<syntaxhighlight lang="elm">module Main exposing (main)
import Html exposing (Html, text, div, p)
import Html.Attributes exposing (style)
change myText =
text ("reverse " ++ myText
++ " = " ++ String.reverse myText)
main =
div [style "margin" "5%", style "font-size" "1.5em"]
[change "as⃝da"
, p []
,
]
</syntaxhighlight>
Link to live demo:
{{out}}
<pre>
reverse as⃝da = ad⃝sa
reverse a⃝su-as⃝u = u⃝sa-us⃝a
reverse Hello! = !olleH
</pre>
=={{header|Emacs Lisp}}==
<syntaxhighlight lang="lisp">(reverse "Hello World")</syntaxhighlight>
{{out}}
<pre>
"dlroW olleH"
</pre>
=={{header|Erlang}}==
<
"!esrever"</
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,
<<T:Size/integer-big>>.</
{{out}}
<pre>
Line 1,039 ⟶ 1,434:
=={{header|ERRE}}==
<syntaxhighlight lang="erre">
PROGRAM REVERSE_STRING
Line 1,055 ⟶ 1,450:
PRINT(R$)
END PROGRAM
</syntaxhighlight>
=={{header|Euler Math Toolbox}}==
<syntaxhighlight lang="euler math toolbox">
>function strrev (s) := chartostr(fliplr(strtochar(s)))
>strrev("This is a test!")
!tset a si sihT
</syntaxhighlight>
=={{header|Euphoria}}==
<
include std/sequence.e
printf(1, "%s\n", {reverse("abcdef") })
</syntaxhighlight>
=={{header|Explore}}==
The [[Scratch]] [[Reverse a string#Scratch|solution]], which requires making variables named "i" and "inv" first, works, unmodified:<br>https://i.ibb.co/3c9k641/Reverse-a-string-in-Explore-using-the-Scratch-solution.png
This example uses a special block located in the Strings category:<br>https://i.ibb.co/4pM9G8b/Reverse-a-string-in-Explore-using-a-special-block.png
=={{header|Ezhil}}==
<syntaxhighlight lang="ezhil">
## இந்த நிரல் தரப்படும் சரம் ஒன்றைத் தலைகீழாகத் திருப்பி அச்சிடும்
Line 1,120 ⟶ 1,520:
பதிப்பி "வேறொரு வகையில் திருப்பியுள்ளோம்: " மீண்டும்திருப்புக(அ)
</syntaxhighlight>
=={{header|F_Sharp|F#}}==
===The function===
<syntaxhighlight lang="fsharp">
// Reverse a string. Nigel Galloway: August 14th., 2019
let strRev α=let N=System.Globalization.StringInfo.GetTextElementEnumerator(α)
List.unfold(fun n->if n then Some(N.GetTextElement(),N.MoveNext()) else None)(N.MoveNext())|>List.rev|>String.concat ""
</syntaxhighlight>
===The Task===
I was a little concerned when entering this task because in the edit window the overline appears above the d, but when previewed it is correctly above the f, using Firefox anyway. Using XTERM the output is correct with the s inside a circle but appears as sO in Firefox.
<syntaxhighlight lang="fsharp">
printfn "%s" (strRev "as⃝df̅")
printfn "%s" (strRev "Nigel")
</syntaxhighlight>
{{out}}
<pre>
f̅ds⃝a
legiN
</pre>
=={{header|Factor}}==
A string is a sequence and there is a default reverse implementation for those.
<syntaxhighlight lang="factor">"hello" reverse</syntaxhighlight>
<code>string-reverse</code> preserves graphemes:
<syntaxhighlight lang="factor">"as⃝df̅" string-reverse "f̅ds⃝a" = .</syntaxhighlight>
=={{header|FALSE}}==
This solution does not take into account combination characters:
<syntaxhighlight lang="false">1_
[^$1_=~][]#%
[$1_=~][,]#</syntaxhighlight>
This solution does take into account combination characters (except for half-marks):
<syntaxhighlight lang="false">1_
[^$1_=~][
$$767>\879\>&
1ø$7615>\7620\>&|
1ø$8399>\8428\>&|
[\]?
]#%
[$1_=~][,]#</syntaxhighlight>
=={{header|Fancy}}==
<syntaxhighlight lang="fancy">"hello world!" reverse</syntaxhighlight>
=={{header|FBSL}}==
A slow way
<
dim $b = ""
REPEAT len(p1)
Line 1,132 ⟶ 1,575:
return b
End Function
</syntaxhighlight>
A much faster (twice at least) way
<
dim $b = "", %i
for i = len(p1) DOWNTO 1
Line 1,141 ⟶ 1,584:
next
return b
End Function</
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)
Line 1,151 ⟶ 1,594:
RETURN s
end function
</syntaxhighlight>
An even faster way using the DynC (Dynamic C) mode
<
void rev(char *str)
{
Line 1,173 ⟶ 1,616:
return theString;
}
End DynC</
Using DynASM, the Dynamic Assembler mode.
<
// get length of string
// divide by two
Line 1,225 ⟶ 1,668:
RET
END DYNASM
</syntaxhighlight>
=={{header|
In this language, strings are very limited and are not designed to store large text data, so there are no built-in operations to work with strings. But with the C API you can make functions that convert a string to a list and vice versa.
<syntaxhighlight lang="c">
#define MAXSTRINGLEN ( 1024 )
/* chop string to list of single character strings */
static fe_Object* chop(fe_Context *ctx, fe_Object *args) {
char buf[MAXSTRINGLEN];
int len = fe_tostring(ctx, fe_nextarg(ctx, &args), buf, sizeof(buf));
int gc = fe_savegc(ctx);
args = fe_bool(ctx, 0);
while (len > 0) {
buf[len--] = '\0';
args = fe_cons(ctx, fe_string(ctx, buf + len), args);
fe_restoregc(ctx, gc);
fe_pushgc(ctx, args);
}
return args;
}
/* pack list of strings to single string */
static fe_Object* pack(fe_Context *ctx, fe_Object *args) {
char buf[MAXSTRINGLEN], *ptr = buf;
for (args = fe_nextarg(ctx, &args); !fe_isnil(ctx, args);) {
ptr += fe_tostring(ctx, fe_nextarg(ctx, &args), ptr, buf + sizeof(buf) - ptr);
}
return fe_string(ctx, buf);
}
</syntaxhighlight>
So, we can manipulate strings like lists:
<syntaxhighlight lang="clojure">
; reverse list
(= reverse (fn (lst)
(let res nil)
(while lst
(= res (cons (car lst) res))
(= lst (cdr lst)))
res))
; chop string to list, reverse list and pack it back to string
(print (pack (reverse (chop "Hello world!"))))
</syntaxhighlight>
Output:
<syntaxhighlight lang="clojure">
!dlrow olleH
</syntaxhighlight>
=={{header|Fennel}}==
Uses the same methods (and suffers from the same limitations) as [[#Lua|the Lua example]].
<syntaxhighlight lang="fennel">
(let [example :asdf]
(string.reverse example) ; fdsa
(example:reverse) ; fdsa
nil)
</syntaxhighlight>
=={{header|Forth}}==
=== Method 1 ===
<
2dup c@ swap c@ rot c! swap c! ;
: reverse ( c-addr u -- )
Line 1,281 ⟶ 1,737:
repeat 2drop ;
s" testing" 2dup reverse type \ gnitset</
=== Method 2 Using the stack ===
<
: mystring ( -- caddr len) S" ABCDEFGHIJKLMNOPQRSTUVWXYZ987654321" ;
Line 1,290 ⟶ 1,746:
: pushstr ( caddr len -- c..c[n]) bounds do I c@ loop ;
: popstr ( c.. c[n] caddr len -- ) bounds do I c! loop ;
: reverse ( caddr len -- ) 2dup 2>r pushstr 2r> popstr ;</
Forth Console Output
Line 1,305 ⟶ 1,761:
The xchars wordset offers several ways to skin this cat; this is just one way to do it, not necessarily the best one. Because the xchars wordset currently does not support recognizing combining characters, this code does not get extra credit.
<
u allocate throw u + c-addr swap over u + >r begin ( from to r:end)
over r@ u< while
Line 1,313 ⟶ 1,769:
\ example use
s" ώщыē" xreverse type \ outputs "ēыщώ"</
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<
CHARACTER(80) :: str = "This is a string"
Line 1,332 ⟶ 1,788:
WRITE(*,*) str
END PROGRAM Example</
{{out}}
This is a string
gnirts a si sihT
Another implementation that uses a recursive not-in-place algorithm:
<
implicit none
Line 1,361 ⟶ 1,817:
end function reverse
end program reverse_string</
{{out}}
<pre>no devil lived on
Line 1,367 ⟶ 1,823:
Another shorter implementation (adapted version from stackoverflow question 10605574 how-to-reverse-a-chain-of-character-fortran-90):
<
implicit none
character (80) :: cadena
Line 1,379 ⟶ 1,835:
write (*,*) cadena
!
end program reverse_string</
{{out}}
<pre>
Line 1,386 ⟶ 1,842:
=={{header|FreeBASIC}}==
<
Function ReverseString(s As Const String) As String
Line 1,399 ⟶ 1,855:
Dim s As String = "asdf"
Print "'"; s; "' reversed is '"; ReverseString(s); "'"</
{{out}}
Line 1,414 ⟶ 1,870:
For example, the string "g\u0308o" represents a g with combining diaeresis, followed by the letter o. Or, in other words, "g̈o". Note that while there are three Unicode codepoints, only two "graphemes" are displayed. Using Frink's smart "reverse" function preserves these combined graphemes. A naive reverse would move the diaeresis over the o instead of the g.
<
=={{header|
Futhark has no real strings beyond a little bit of syntactic sugar, so this is the same as reversing an array.
<syntaxhighlight lang="futhark">
fun main(s: []i32) = s[::-1]
</syntaxhighlight>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">void local fn DoIt
CFStringRef s1 = @"asdf", s2 = @""
long index
for index = len(s1) - 1 to 0 step -1
s2 = fn StringByAppendingString( s2, mid(s1,index,1) )
next
print s1,s2
end fn
window 1
fn DoIt
HandleEvents</syntaxhighlight>
Output:<pre>
asdf fdsa</pre>
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=e32989a1ffdc4428075ca6d4cb15dfa6 Click this link to run this code]'''
<
Dim sString As String = "asdf"
Dim sOutput As String
Line 1,461 ⟶ 1,912:
Print sOutput
End</
Output:
<pre>
Line 1,468 ⟶ 1,919:
=={{header|GAP}}==
<
# "fedcba"</
=={{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|Genie}}==
Pretty sure the output capture fails the extra credit, but that may be more local setup and font installs rather than the glib functions used.
<
/*
Reverse a string, in Genie
Line 1,494 ⟶ 1,945:
print combining
print combining.reverse()</
{{out}}
Line 1,507 ⟶ 1,958:
=={{header|GFA Basic}}==
<syntaxhighlight lang="text">
PRINT @reverse$("asdf")
'
Line 1,518 ⟶ 1,969:
RETURN result$
ENDFUNC
</syntaxhighlight>
=={{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 (
Line 1,597 ⟶ 2,048:
r = reversePreservingCombiningCharacters(s)
fmt.Println("combining characters:", []rune(r), r)
}</
{{out}}
<pre>
Line 1,615 ⟶ 2,066:
=={{header|Groovy}}==
=====Solution:=====
<
{{out}}
<pre>.ablE was I ere' ,I saw elbA</pre>
=====Extra Credit:=====
<
List combiningBlocks = [
Line 1,634 ⟶ 2,085:
}
}
println chars.reverse().join()</
{{out}}
<pre>f̅ds⃝a</pre>
=={{header|Harbour}}==
<
LOCAL cOut := "", i
Line 1,647 ⟶ 2,098:
NEXT
RETURN cOut</
=={{header|Haskell}}==
<
This function as defined in the Haskell Prelude.
Line 1,656 ⟶ 2,107:
Perhaps, for example:
<
accumulatingReverse lst =
let rev xs a = foldl (flip (:)) a xs
in rev lst []</
===Supporting combining characters===
<
import Data.List (groupBy)
myReverse = concat . reverse . groupBy (const isMark)</
<code>groupBy (const isMark)</code> is an unusual way of splitting a string into its combined characters
=={{header|HicEst}}==
<
L = LEN( string )
Line 1,677 ⟶ 2,128:
ENDDO
WRITE(Messagebox, Name) string </
=={{header|Icon}} and {{header|Unicon}}==
<
s := \arglist[1] | "asdf"
write(s," <-> ", reverse(s)) # reverse is built-in
end</
=={{header|Io}}==
<
=={{Header|Insitux}}==
<syntaxhighlight lang="insitux">
(reverse "hello")
</syntaxhighlight>
=={{header|J}}==
Reverse (<tt>|.</tt>) reverses a list of items (of any shape or type).
<
fdsa</
Extra credit:
First, a function to determine whether a Unicode character is a combining character:
<
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.
<
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.
<
f̅ds⃝a</
=={{header|Java}}==
=== Reverse Unicode Codepoints ===
Reversing codepoints works in most cases when reversing single characters wherever they are encoded on multi-bytes or not. But this doesn't work for composed characters.
<syntaxhighlight lang="java">
String reversed = new StringBuilder("as⃝df̅").reverse().toString(); // fd⃝sa
String reversed = new StringBuffer("as⃝df̅").reverse().toString(); // fd⃝sa
</syntaxhighlight>
Alternately, you could use a for-loop with the same issue.
<syntaxhighlight lang="java">
String string = "as⃝df̅";
StringBuilder reversed = new StringBuilder();
for (int index = string.length() - 1; index >= 0; index--)
reversed.append(string.charAt(index));
reversed; // fd⃝sa
</syntaxhighlight>
=== Reverse Unicode Graphemes ===
A third-party solution is to use [https://mvnrepository.com/artifact/com.ibm.icu/icu4j ICU4J].
A native solution, since JDK 15, is to use <code>Pattern.compile( "\\X" )</code> from <code>java.util.regex</code> to parse grapemes.
Another native solution, since JDK 20, is to use <code>java.text.BreakIterator</code> class that now parse graphemes correctly<ref>https://bugs.openjdk.org/browse/JDK-8291660</ref>.
<syntaxhighlight lang="java">
import java.text.BreakIterator;
public class Reverse {
/* works with Java 20+ only
* cf. https://bugs.openjdk.org/browse/JDK-8291660
*/
public static StringBuilder graphemeReverse(String text) {
BreakIterator boundary = BreakIterator.getCharacterInstance();
boundary.setText(text);
StringBuilder reversed = new StringBuilder();
int end = boundary.last();
int start = boundary.previous();
while (start != BreakIterator.DONE) {
reversed.append(text.substring(start, end));
end = start;
start = boundary.previous();
}
return reversed;
}
public static void main(String[] args) throws Exception {
String a = "as⃝df̅";
System.out.println(graphemeReverse(a)); // f̅ds⃝a
}
}
</syntaxhighlight>
=={{header|JavaScript}}==
===
==== Split code points ====
<code><nowiki>split('')</nowiki></code> (with empty string argument) works only for ASCII. For Unicode strings, one of the two following methods can be used.
<syntaxhighlight lang="javascript">
example = 'Tux 🐧 penguin';
// array expansion operator
[...example].reverse().join('') // 'niugnep 🐧 xuT'
// split regexp separator with Unicode mode
example.split(/(?:)/u).reverse().join('') // 'niugnep 🐧 xuT'
// do not use
example.split('').reverse().join(''); // 'niugnep \udc27\ud83d xuT'
</syntaxhighlight>
==== Split graphemes =====
More generally, one would want to combine characters such as joining emojis or diacritics to be handled properly so enumerating over graphemes is a must.
<syntaxhighlight lang="javascript">
a = "\u{1F466}\u{1F3FB}\u{1f44b}"; // '👦🏻👋'
// wrong behavior - ASCII sequences
a.split('').reverse().join(''); // '\udc4b🁦\ud83d'
// wrong behavior - Unicode code points
[...a].reverse().join(''); // '👋🏻👦'
a.split(/(?:)/u).reverse().join(''); // '👋🏻👦'
// correct behavior - Unicode graphemes
[...new Intl.Segmenter().segment(a)].map(x => x.segment).reverse().join('') // 👋👦🏻
</syntaxhighlight>
=== ASCII ===
==== ES5 ====
<
function reverseStr(s) {
return s.split('').reverse().join('');
Line 1,732 ⟶ 2,274:
while (i--) o += s[i];
return o;
}</
==== ES6 ====
<
// .reduceRight() can be useful when reversals
Line 1,753 ⟶ 2,295:
.map(f => f("Some string to be reversed"));
})();</
{{Out}}
<
=={{header|Joy}}==
<syntaxhighlight lang="joy">DEFINE reverse == "" [swons] fold.
"asdf" reverse putchars.</syntaxhighlight>
{{out}}
<pre>fdsa</pre>
=={{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.
<
'''Examples''':
"nöel" | reverse_string # => "leön"
Line 1,771 ⟶ 2,320:
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''.
<
puts(str);
puts(str.split('').reverse().join(''));</
{{out}}
<pre>Never odd or even
Line 1,779 ⟶ 2,328:
=={{header|Julia}}==
<
"yeh"</
The <code>reverse</code> 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:
<
"f̅ds⃝a"</
=={{header|K}}==
Monadic reverse (| ) verb reverses a string or list of any shape
<syntaxhighlight lang="k">
|"asdf"
"fdsa"
Line 1,793 ⟶ 2,342:
| 23 4 5 1
1 5 4 23
</syntaxhighlight>
=={{header|Kotlin}}==
<
println("asdf".reversed())
}</
=={{header|L++}}==
<
(main
(decl std::string s)
(std::getline std::cin s)
(std::reverse (s.begin) (s.end))
(prn s))</
=={{header|LabVIEW}}==
{{VI solution|LabVIEW_Reverse_a_string.png}}
=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
{S.reverse hello brave new world}
-> world new brave hello
</syntaxhighlight>
=={{header|Lang}}==
<syntaxhighlight lang="lang">
# Inv operator
fn.println(parser.op(-asdf))
# Ouput: fdsa
# Inv operator function
fn.println(fn.inv(asdf))
# Ouput: fdsa
</syntaxhighlight>
=={{header|Lang5}}==
<
"qwer asdf" flip .</
=={{header|langur}}==
The reverse() function will reverse a string according to graphemes.
<syntaxhighlight lang="langur">writeln reverse "don't you know"</syntaxhighlight>
{{out}}
<pre>wonk uoy t'nod</pre>
=={{header|Lasso}}==
<
#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.
<
with i in #input->values
do #output->insertFirst(#i)
#output->join</
=={{header|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 <tt>PUTS</tt> to print it.
<
LEA R1,STRING
Line 1,863 ⟶ 2,436:
GNIRTS .BLKW 128
.END</
{{out}}
<pre>d'gnahc woh !n'llaf woh O tub -- eh tseeb uoht fI</pre>
Line 1,870 ⟶ 2,443:
Ordinary string:
<
> (lists:reverse "asdf")
"fdsa"
</syntaxhighlight>
Create a UTF-8 encoded string:
<
> (set encoded (binary ("åäö ð" utf8)))
#B(195 165 195 164 195 182 32 195 176)
</syntaxhighlight>
Display it, to be sure:
<
> (io:format "~tp~n" (list encoded))
<<"åäö ð"/utf8>>
</syntaxhighlight>
Reverse it:
<
> (lists:reverse (unicode:characters_to_list encoded))
"ð öäå"
</syntaxhighlight>
=={{header|Liberty BASIC}}==
{{works with|Just BASIC}}
{{works with|Run BASIC}}
<syntaxhighlight lang="lb">input$ ="abcdefgABCDEFG012345"
print input$
print ReversedStr$( input$)
Line 1,905 ⟶ 2,479:
ReversedStr$ =ReversedStr$ +mid$( in$, i, 1)
next i
end function</
=={{header|Lingo}}==
Lingo strings are always UTF-8 encoded and string operations are based on Unicode code points, so the "extra credit" is built-in:
<
res = ""
repeat with i = str.length down to 1
Line 1,915 ⟶ 2,489:
end repeat
return res
end</
To reverse a string byte-wise, the ByteArray data type has to be used:
<
ba = byteArray(str)
res = byteArray()
Line 1,924 ⟶ 2,498:
end repeat
return res
end</
=={{header|LiveCode}}==
<
repeat with i = length(S) down to 1
put char i of S after R
end repeat
return R
end reverseString</
=={{header|LLVM}}==
<
; 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.
Line 2,021 ⟶ 2,595:
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32, i1)
declare i64 @strlen(i8*)</
{{out}}
<pre>Hello world
Line 2,028 ⟶ 2,602:
=={{header|Logo}}==
REVERSE works on both words and lists.
<
=={{header|Lua}}==
Built-in string.reverse(s) or s:reverse().
=== ASCII ===
<syntaxhighlight lang="lua">
example = 'asdf'
string.reverse(example) -- fdsa
example:reverse() -- fdsa
</syntaxhighlight>
=== Unicode ===
Lua doesn't support Unicode strings.
=={{header|M2000 Interpreter}}==
===Using Custom Function===
Version 2, using insert to string (with no copies of strings)
<syntaxhighlight lang="m2000 interpreter">
Module ReverseString {
a$="as⃝df̅"
Line 2,063 ⟶ 2,649:
}
ReverseString
</syntaxhighlight>
===using StrRev$()===
this function (new to 9.5 version) use StrReverse from Vb6
<syntaxhighlight lang="m2000 interpreter">
a$="as⃝df̅"
b$=strrev$(a$)
clipboard b$
Print b$="̅fd⃝sa"
</syntaxhighlight>
=={{header|M4}}==
<
=={{header|Maclisp}}==
<
Output:
<pre>"gnirts-ym"</pre>
=={{header|MACRO-11}}==
<syntaxhighlight lang="macro11"> .TITLE REVERS
.MCALL .GTLIN,.PRINT,.EXIT
REVERS::.GTLIN #1$ ; READ STRING
MOV #1$,R0
JSR PC,REV ; REVERSE IT
.PRINT #1$ ; PRINT RESULT
.EXIT
1$: .BLKB 200
; REVERSE STRING AT R0
REV: MOV R0,R1
1$: TSTB (R1)+ ; FIND END OF STRING
BNE 1$
DEC R1 ; MOVE BACK TO LAST CHAR
2$: MOVB -(R1),R2 ; SWAP CHARS
MOVB (R0),(R1)
MOVB R2,(R0)+
CMP R0,R1 ; STOP WHEN POINTERS MEET
BLT 2$
RTS PC
.END REVERS</syntaxhighlight>
{{out}}
<pre>.revers
A man, a plan, a canal: Panama
amanaP :lanac a ,nalp a ,nam A</pre>
=={{header|Maple}}==
<
"oof"</
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
=={{header|MATLAB}}==
Line 2,093 ⟶ 2,707:
Sample Usage:
<
'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</
=={{header|Maxima}}==
<
sreverse("rats live on no evil star"); /* not a bug :o) */</
=={{header|MAXScript}}==
<
(
local reversed = ""
for i in s.count to 1 by -1 do reversed += s[i]
reversed
)</
=={{header|min}}==
{{works with|min|0.19.3}}
<
=={{header|MiniScript}}==
<
print "Forward: " + str
newStr = ""
Line 2,124 ⟶ 2,738:
newStr = newStr + str[i]
end for
print "Reversed: " + newStr</
{{out}}
<pre>
Line 2,132 ⟶ 2,746:
=={{header|MIPS Assembly}}==
<
# First, it gets the length of the original string
# Then, it allocates memory from the copy
Line 2,144 ⟶ 2,757:
# decrement source pointer
# increment target pointer
.text
strcpy:
addi $sp, $sp, -4
sw $s0, 0($sp)
add $s0, $zero, $zero
L1:
add $t1, $s0, $a1
lb $t2, 0($t1)
add $t3, $s0, $a0
sb $t2, 0($t3)
beq $t2, $zero, L2
addi $s0, $s0, 1
j L1
L2:
lw $s0, 0($sp)
addi $sp, $sp, 4
jr $ra
.data
ex_msg_og: .asciiz "Original string:\n"
ex_msg_cpy: .asciiz "\nCopied string:\n"
string: .asciiz "
</syntaxhighlight>
=={{header|Mirah}}==
<
StringBuilder.new(s).reverse
end
puts reverse('reversed')</
=={{header|Miranda}}==
<syntaxhighlight lang="miranda">main :: [sys_message]
main = [Stdout (reverse "esreveR"),
Stdout "\n"]</syntaxhighlight>
{{out}}
<pre>Reverse</pre>
=={{header|Modula-2}}==
<
FROM FormatString IMPORT FormatString;
FROM Terminal IMPORT Write,WriteString,WriteLn,ReadChar;
Line 2,251 ⟶ 2,839:
ReadChar
END ReverseStr.</
=={{header|Modula-3}}==
<
IMPORT IO, Text;
Line 2,269 ⟶ 2,857:
BEGIN
IO.Put(String("Foobarbaz") & "\n");
END Reverse.</
{{out}}
<pre>
Line 2,276 ⟶ 2,864:
=={{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)
QUIT</
{{out}}
<pre>
Line 2,290 ⟶ 2,878:
=={{header|Nanoquery}}==
<
l = ""
Line 2,298 ⟶ 2,886:
return l
end</
=={{header|Neko}}==
No extra credit for UTF in this example.
<
var reverse = function(s) {
Line 2,331 ⟶ 2,919:
str = ""
$print(str, "\n")
$print(reverse(str), "\n")</
{{out}}
<pre>prompt$ nekoc reverse.neko
Line 2,352 ⟶ 2,940:
===Supporting Combining Characters===
Compile with:<pre>ncc -reference:System.Windows.Forms reverse.n</pre>
<
using System.Globalization;
using System.Windows.Forms;
Line 2,374 ⟶ 2,962:
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 = [];
Line 2,383 ⟶ 2,971:
output ::= c.ToString();
Concat("", output)
}</
=={{header|NetRexx}}==
<
options replace format comments java crossref savelog symbols nobinary
Line 2,396 ⟶ 2,984:
say sihTesrever
return</
{{out}}
<pre>
Line 2,404 ⟶ 2,992:
=={{header|NewLISP}}==
<
=={{header|Nial}}==
<
=fdsa</
=={{header|Nim}}==
=== Unicode codepoints ===
Since Nim 0.11.0, the <code>unicode</code> module provides a [https://nim-lang.github.io/Nim/unicode.html#reversed%2Cstring <code>reversed</code>] proc...
Hence:
<syntaxhighlight lang="nim">
import unicode
doAssert "foobar".reversed == "raboof"
doAssert "先秦兩漢".reversed == "漢兩秦先"
</syntaxhighlight>
This proc is enumerating codepoints so it will work with Unicode multi-bytes characters. A special handling was added so it's supports composing as well but since it's not enumerating graphemes it won't work with joining.
=== Unicode graphemes ===
There is no native method to handle grapheme currently.
=={{header|NS-HUBASIC}}==
<
20 REVERSED$=""
30 FOR I=1 TO LEN(STRING$)
40 REVERSED$=MID$(STRING$,I,1)+REVERSED$
50 NEXT
60 PRINT REVERSED$</
=={{header|Oberon-2}}==
Tested with [https://miasap.se/obnc OBNC].
<
IMPORT Out, Strings;
Line 2,505 ⟶ 3,055:
Out.String(s);
Out.Ln
END reverse.</
=={{header|Objeck}}==
<
result := "asdf"->Reverse();
</syntaxhighlight>
=={{header|Objective-C}}==
This extends the <code>NSString</code> object adding a <code>reverseString</code> class method.
<
@interface NSString (Extended)
Line 2,533 ⟶ 3,083:
return rtr;
}
@end</
Usage example:
<
{
@autoreleasepool {
Line 2,545 ⟶ 3,095:
}
return 0;
}</
===Supporting combining characters===
Extra credit
<
@interface NSString (Extended)
Line 2,567 ⟶ 3,117:
return ostr;
}
@end</
Usage example:
<
{
@autoreleasepool {
Line 2,579 ⟶ 3,129:
}
return 0;
}</
=={{header|OCaml}}==
Line 2,588 ⟶ 3,138:
{{works with|OCaml|4.02+}}
<
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 last = Bytes.length bs - 1 in
for i = 0 to last / 2 do
Line 2,611 ⟶ 3,161:
print_bytes s;
print_newline ();
;;</
Here is a 100% functionnal string reversing function:
<
if List.length list = String.length strin
then String.concat "" list
Line 2,622 ⟶ 3,172:
let () =
print_endline (revs "Hello World!")</
will return "!dlroW olleH"
=={{header|Octave}}==
<
rev = s(length(s):-1:1)</
=={{header|Oforth}}==
<syntaxhighlight lang
=={{header|Ol}}==
<
(define (rev s)
(runes->string (reverse (string->runes s))))
; testing:
(print (rev "
; ==>
</syntaxhighlight>
=={{header|OOC}}==
<syntaxhighlight lang="ooc">
main: func {
"asdf" reverse() println() // prints "fdsa"
}
</syntaxhighlight>
=={{header|OpenEdge/Progress}}==
<syntaxhighlight lang
INPUT i_c AS CHARACTER
):
Line 2,658 ⟶ 3,215:
END FUNCTION.
MESSAGE reverseString( "asdf" ) VIEW-AS ALERT-BOX.</
=={{header|OxygenBasic}}==
<
'8 BIT CHARACTERS
Line 2,702 ⟶ 3,252:
'
print s
</syntaxhighlight>
==OxygenBasic x86 Assembler==
32 bit code, 8-bit characters:
<
string s="qwertyuiop"
Line 2,727 ⟶ 3,277:
print s
</syntaxhighlight>
=={{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
Line 2,741 ⟶ 3,291:
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.
Line 2,747 ⟶ 3,297:
===Version #1.===
<
===Version #2.===
{{Works with|PARI/GP|2.7.4 and above}}
<
\\ Return reversed string str.
\\ 3/3/2016 aev
Line 2,765 ⟶ 3,315:
for(i=1,n, sr=sreverse(s));
}
</
{{Output}}
Line 2,775 ⟶ 3,325:
</pre>
<
\\ Version #1 upgraded to complete function. Practically the same.
reverse(str)={return(concat(Vecrev(str)))}
Line 2,787 ⟶ 3,337:
for(i=1,n, sr=reverse(s));
}
</
{{Output}}
Line 2,803 ⟶ 3,353:
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
Line 2,811 ⟶ 3,361:
for i := 0 to len-1 do
result[min1 + len-1 - i] := s[min + i]
end;</
<
function revstr(my_s:string):string;
var out_s:string;
Line 2,821 ⟶ 3,371:
out_s:=out_s+my_s[ls-i+1];
revstr:=out_s;
end;</
=== Extended Pascal, Turbo Pascal, Delphi and compatible compilers ===
<
var i:integer;
var tmp:char;
Line 2,834 ⟶ 3,384:
reverse:=s;
end;
end;</
alternative as procedure which changes the original
<
var
i,j:integer;
Line 2,851 ⟶ 3,401:
dec(j)
end;
end;</
=={{header|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 <pre>子垫在坐猫</pre> which Google Translate renders as <pre>Sub-pad sitting cat</pre>.
The same again but with everything in Korean.
<
Reversing the Korean makes an untranslatable-by-Google mess of the sentence, viz <pre>아앉 에위 트매 가이양고</pre>.
The short-opcode version in English dialect is
<
Peloton works in Unicode.
=={{header|Perl}}==
[https://perldoc.perl.org/functions/reverse reverse()] works in the context of a List or a scalar, not a string.
<syntaxhighlight lang="perl">use utf8;
binmode STDOUT, ":utf8";
# to reverse characters (code points):
print scalar reverse('visor'), "\n";
# to reverse graphemes:
Line 2,877 ⟶ 3,430:
$string = 'ℵΑΩ 駱駝道 🤔 🇸🇧 🇺🇸 🇬🇧 👨👩👧👦🆗🗺';
print join("", reverse $string =~ /\X/g), "\n";</
{{out}}
<pre>rosiv
Line 2,883 ⟶ 3,436:
🗺🆗👨👩👧👦 🇬🇧 🇺🇸 🇸🇧 🤔 道駝駱 ΩΑℵ</pre>
=={{header|
<syntaxhighlight lang="pharo">'123' reversed</syntaxhighlight>
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">reverse</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"asdf"</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
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). It actually works better under pwa/p2js than on desktop/Phix, you can find a copy of this code in demo/HelloUTF8.exw which outputs the result in a message box and therefore looks much better on the latter.<br>
Note that [[XXXX_redacted#Phix]] adds some ZERO-WIDTH-JOINER handling to the inner code.
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">unicode_reverse</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">utf8</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">utf32</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">utf8_to_utf32</span><span style="color: #0000FF;">(</span><span style="color: #000000;">utf8</span><span style="color: #0000FF;">)</span>
<span style="color: #000080;font-style:italic;">-- The assumption is made that <char><comb1><comb2>
-- and <char><comb2><comb1> etc would work the same.
-- The following loop converts <char><comb1><comb2>
-- to <comb1><comb2><char>, as a pre-reverse() step.</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">utf32</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">ch</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">utf32</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
<span style="color: #008080;">if</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">ch</span><span style="color: #0000FF;">>=</span><span style="color: #000000;">0x300</span> <span style="color: #008080;">and</span> <span style="color: #000000;">ch</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">0x36f</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">or</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">ch</span><span style="color: #0000FF;">>=</span><span style="color: #000000;">0x1dc0</span> <span style="color: #008080;">and</span> <span style="color: #000000;">ch</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">0x1dff</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">or</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">ch</span><span style="color: #0000FF;">>=</span><span style="color: #000000;">0x20d0</span> <span style="color: #008080;">and</span> <span style="color: #000000;">ch</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">0x20ff</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">or</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">ch</span><span style="color: #0000FF;">>=</span><span style="color: #000000;">0xfe20</span> <span style="color: #008080;">and</span> <span style="color: #000000;">ch</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">0xfe2f</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">utf32</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">utf32</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span>
<span style="color: #000000;">utf32</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">ch</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #000000;">utf32</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">reverse</span><span style="color: #0000FF;">(</span><span style="color: #000000;">utf32</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">utf8</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">utf32_to_utf8</span><span style="color: #0000FF;">(</span><span style="color: #000000;">utf32</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">utf8</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">r4</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"as\u203Ddf\u0305"</span><span style="color: #0000FF;">,</span>
<span style="color: #000000;">rt</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">r4</span><span style="color: #0000FF;">&</span><span style="color: #008000;">" reversed is "</span><span style="color: #0000FF;">&</span><span style="color: #000000;">unicode_reverse</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r4</span><span style="color: #0000FF;">)&</span><span style="color: #008000;">"\n"</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">rt</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
=={{header|PHP}}==
=== Unicode ===
==== Code points ====
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>.
<syntaxhighlight lang="php">
// 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)));
</syntaxhighlight>
With PHP 7.4+ and 8+, it's also possible to use <code>mb_str_split()</code>, which may ends easier.
<syntaxhighlight lang="php">
implode('', array_reverse(mb_str_split($string)));
</syntaxhighlight>
==== Graphemes ====
When using combining characters such as diacritics or ZWJ (joining), reversing code points will mess with the result, reversing the graphemes instead is mandatory. This is generally the best and safest approach. As there is no <code>grapheme_reverse()</code> function or grapheme iterator, one has to implement it with <code>grapheme_strlen</code> and <code>grapheme_substr</code>. In PHP, there is no Unicode escape sequence so to specify characters by code point a tricks must be used: for example, using the escape sequence of HTML entities and then convert it to a Unicode encoding such as UTF-8.
<syntaxhighlight lang="php">
$a = mb_convert_encoding('👦🏻👋', 'UTF-8', 'HTML-ENTITIES'); // 👦🏻👋
function str_to_array($string)
{
$length = grapheme_strlen($string);
$ret = [];
for ($i = 0; $i < $length; $i += 1) {
$ret[] = grapheme_substr($string, $i, 1);
}
return $ret;
}
function utf8_strrev($string)
{
return implode(array_reverse(str_to_array($string)));
}
print_r(utf8_strrev($a)); // 👋👦🏻
</syntaxhighlight>
=== ASCII ===
<syntaxhighlight lang="php">strrev($string);</syntaxhighlight>
=={{header|PicoLisp}}==
<
{{out}}
<pre>-> "ßÜÖÄüöä"</pre>
Line 2,930 ⟶ 3,530:
=={{header|Pike}}==
For simple ASCII:
<
{{out}}
<pre>"oof"</pre>
Line 2,939 ⟶ 3,539:
if sent raw wide strings.
<
void main()
{
string s = "ßÜÖÄüöää ἀρχῇ";
write("%s\n", string_to_utf8( reverse(s) ));
}</
{{out}}
<pre>
Line 2,951 ⟶ 3,551:
=={{header|PL/I}}==
<
=={{header|Plain English}}==
<syntaxhighlight lang="plainenglish">To run:
Start up.
Put "asdf" into a string.
Reverse the string.
Shut down.</syntaxhighlight>
=={{header|plainTeX}}==
Works well if the string has no space (spaces are gobbled).
<
\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:
<pre>attesoR</pre>
=={{header|Pop11}}==
<syntaxhighlight lang="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;</syntaxhighlight>
=={{header|PostScript}}==
The following implementation works on arrays of numerics as well as characters ( string ).
<
/str exch def
/temp str 0 get def
Line 2,990 ⟶ 3,595:
}repeat
str pstack
}def</
{{Out}}
<
[3 2 1]
(Hello World) reverse % input
(dlroW olleH)</
=={{header|PowerBASIC}}==
<
#COMPILER PBCC 6
FUNCTION PBMAIN () AS LONG
CON.PRINT STRREVERSE$("PowerBASIC")
END FUNCTION</
=={{header|PowerShell}}==
=== For ASCII ===
Test string
<
====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}}
<
{{works with|PowerShell|2}}
<
{{works with|PowerShell|2}}
<syntaxhighlight lang
====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.Length),
[string]::Join('', ($s.Length..1 | ForEach-Object { "`$$_" }))</
{{works with|PowerShell|2}}
<
('(.)' * $s.Length),
-join ($s.Length..1 | ForEach-Object { "`$$_" } )</
{{works with|PowerShell|3}}
<syntaxhighlight lang="powershell">
[Regex]::Matches(
</syntaxhighlight>
=== For Unicode ===
==== For codepoints ====
Since PowerShell 7, there is a <code>EnumerateRunes()</code> method to enumerate Unicode codepoints. Enumerating codepoints works for multi-bytes characters but not for composing or joining.
<syntaxhighlight lang="powershell">
$a = 'abc 🐧 def'
$enum = $a.EnumerateRunes() | % { "$_" }
-join $enum[$enum.length..0] # fed 🐧 cba
</syntaxhighlight>
==== For graphemes ====
For composing or joining, enumerating graphemes is required.
<syntaxhighlight lang="powershell">
$a = "aeiou`u{0308}yz"
$enum = [System.Globalization.StringInfo]::GetTextElementEnumerator($a)
$arr = @()
while($enum.MoveNext()) { $arr += $enum.GetTextElement() }
[array]::reverse($arr)
$arr -join '' # zyüoiea
</syntaxhighlight>
=={{header|Prolog}}==
{{works with|SWI Prolog}}
<
{{Out}}
<pre>
Line 3,046 ⟶ 3,675:
The main workings are hidden inside the reverse/2 predicate,
so lets write one to see how it works:
<
accRev([], A, A).
rev(L,R) :- accRev(L,[],R).</
=={{header|PureBasic}}==
<
=={{header|Python}}==
===Optimized for user input===
<syntaxhighlight lang
===Already known string===
<syntaxhighlight lang
or
<syntaxhighlight lang
===Python: Unicode reversal===
Line 3,067 ⟶ 3,696:
'''Note:''' How this looks may be subject to how the tool you are using to view this page can render Unicode.
<
def ureverse(ustring):
Line 3,095 ⟶ 3,724:
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}}
Line 3,105 ⟶ 3,734:
If this code is then used:
<
'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}}
Line 3,117 ⟶ 3,746:
'''This uses the unicode string mentioned in the task:'''
<
for n in ['61', '73', '20dd', '64', '66', '305'])
say_rev(ucode)</
It produces this output
{{out}}
Line 3,126 ⟶ 3,755:
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</pre>
=={{header|Quackery}}==
reverse is predefined (and applies to nests in general, including strings) as:
<syntaxhighlight lang="quackery"> [ dup nest? if
[ [] swap witheach
[ nested
swap join ] ] ] is reverse ( x --> x )</syntaxhighlight>
=={{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(
Line 3,140 ⟶ 3,777:
,collapse="")
)
}</
Alternatively (using rev() function):
<
<
revstring("m\u00f8\u00f8se")
Encoding("m\u00f8\u00f8se") # just to check if on your system it's something
# different!</
{{out}}
<pre>
Line 3,157 ⟶ 3,794:
</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}}==
Line 3,166 ⟶ 3,799:
As in Scheme:
<
(define (string-reverse s)
(list->string (reverse (string->list s))))
(string-reverse "aoeu")</
{{out}}
Line 3,178 ⟶ 3,811:
"ueoa"
> </pre>
=={{header|Raku}}==
(formerly Perl 6)
{{Works with|rakudo|2018.08}}
Raku handles graphemes, multi-byte characters and emoji correctly by default.
<syntaxhighlight lang="raku" line>say "hello world".flip;
say "as⃝df̅".flip;
say 'ℵΑΩ 駱駝道 🤔 🇸🇧 🇺🇸 🇬🇧 👨👩👧👦🆗🗺'.flip;</syntaxhighlight>
{{out}}
<pre>dlrow olleh
f̅ds⃝a
🗺🆗👨👩👧👦 🇬🇧 🇺🇸 🇸🇧 🤔 道駝駱 ΩΑℵ</pre>
=={{header|RapidQ}}==
<syntaxhighlight lang="vb">
print reverse$("This is a test")
</syntaxhighlight>
=={{header|Rascal}}==
<syntaxhighlight lang="rascal">import String;
reverse("string")</syntaxhighlight>
=={{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
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.
=={{header|Red}}==
<
== "fdsa"</
=={{header|Refal}}==
<syntaxhighlight lang="refal">$ENTRY Go {
= <Prout <Reverse 'asdf'>>;
};
Reverse {
(e.X) = e.X;
(e.X) s.C e.Y = <Reverse (s.C e.X) e.Y>;
e.X = <Reverse () e.X>;
};</syntaxhighlight>
{{out}}
<pre>fdsa</pre>
=={{header|ReScript}}==
<syntaxhighlight lang="rescript">let rev_string = (s) => {
let len = Js.String2.length(s)
let arr = []
for i in 0 to (len-1) {
let c = Js.String2.get(s, len - 1 - i)
let _ = Js.Array2.push(arr, c)
}
Js.String2.concatMany("", arr)
}
Js.log(rev_string("abcdefg"))</syntaxhighlight>
{{out}}
<pre>
$ bsc revstr.res > revstr.bs.js
$ node revstr.bs.js
gfedcba
</pre>
=={{header|Retro}}==
<syntaxhighlight lang="retro">'asdf s:reverse s:put</syntaxhighlight>
=={{header|REXX}}==
All methods shown below also work with '''NULL''' values (strings with a zero length).
===using REVERSE BIF===
<
string1 = 'A man, a plan, a canal, Panama!'
Line 3,214 ⟶ 3,895:
say ' original string: ' string1
say ' reversed string: ' string2
/*stick a fork in it, we're done.*/</
'''output'''
<pre>
Line 3,222 ⟶ 3,903:
===using SUBSTR BIF, left to right===
<
string1 = 'A man, a plan, a canal, Panama!'
Line 3,231 ⟶ 3,912:
say ' original string: ' string1
say ' reversed string: ' string2
/*stick a fork in it, we're done.*/</
'''output''' is identical to the 1<sup>st</sup> REXX version.
<br><br>(Regarding the previous example) Another method of coding an abutment (an implied concatenation) is:
<
/*───── or ─────*/
string2= substr(string1,j,1)string2</
===using SUBSTR BIF, right to left===
<
string1 = 'A man, a plan, a canal, Panama!'
Line 3,248 ⟶ 3,929:
say ' original string: ' string1
say ' reversed string: ' string2
/*stick a fork in it, we're done.*/</
'''output''' is identical to the 1<sup>st</sup> version.
<br><br>
=={{header|Ring}}==
<syntaxhighlight lang="ring">
cStr = "asdf" cStr2 = ""
for x = len(cStr) to 1 step -1 cStr2 += cStr[x] next
See cStr2 # fdsa
</syntaxhighlight>
=={{header|RLaB}}==
<
rosettacode
Line 3,264 ⟶ 3,952:
>> rx
edocattesor</
=={{header|Robotic}}==
<
. "local1 = Main string"
. "local2 = Temporary string storage"
Line 3,291 ⟶ 3,972:
* "Reversed string: &$local1& (Length: &$local1.length&)"
end
</syntaxhighlight>
=={{header|RPL}}==
{{works with|Halcyon Calc|4.2.7}}
≪ ""
OVER SIZE 1 '''FOR''' j
OVER j DUP SUB +
-1 '''STEP''' SWAP DROP
≫ '<span style="color:blue">RVSTR</span>' STO
"ABC" <span style="color:blue">RVSTR</span>
{{out}}
<pre>1: "CBA"</pre>
=={{header|Ruby}}==
<
reversed = str.reverse
"résumé niño".reverse #=> "oñin émusér"</syntaxhighlight>
for extra credit
<syntaxhighlight lang="ruby">
graphemes = 'as⃝df̅'.scan(/\X/)
reversed = graphemes.reverse
graphemes.join #=> "f̅ds⃝a"
</syntaxhighlight>
=={{header|Run BASIC}}==
{{works with|Just BASIC}}
{{works with|Liberty BASIC}}
{{works with|QBasic}}
{{works with|Yabasic}}
<syntaxhighlight lang="runbasic">string$ = "123456789abcdefghijk"
for i = len(string$) to 1 step -1
print mid$(string$,i,1);
next i</
=={{header|Rust}}==
Reversing ASCII byte-slice (in-place):
<syntaxhighlight lang="rust">let mut buffer = b"abcdef".to_vec();
buffer.reverse();
assert_eq!(buffer, b"fedcba");</syntaxhighlight>
Reversing Unicode scalar values:
<syntaxhighlight lang="rust">let output: String = "一二三四五六七八九十".chars().rev().collect();
assert_eq!(output, "十九八七六五四三二一");</syntaxhighlight>
Reversing a <code>Chars</code> iterator doesn't solve the complete problem, because it iterates unicode scalar values, which doesn't account for combining marks:
<syntaxhighlight lang="rust">let output: String = "as⃝df̅".chars().rev().collect();
assert_ne!(output, "f̅ds⃝a"); // should be this
assert_eq!(output, "̅fd⃝sa");</syntaxhighlight>
Reversing graphemes clusters, which is provided by the [https://unicode-rs.github.io/unicode-segmentation/unicode_segmentation/struct.Graphemes.html unicode-segmentation] crate, solves the problem:
<syntaxhighlight lang="rust">use unicode_segmentation::UnicodeSegmentation;
let output: String = "as⃝df̅".graphemes(true).rev().collect();
assert_eq!(output, "f̅ds⃝a");</syntaxhighlight>
=={{header|S-lang}}==
Here is an 8-bit version:
<
init_char_array(aa, sa);
array_reverse(aa);
Line 3,336 ⟶ 4,044:
% onto the array:
print( strjoin(array_map(String_Type, &char, aa), "") );</
Output: "dlroW ,olleH"
Line 3,343 ⟶ 4,051:
Side note: If needed, strbytelen() would give total length of string.
<
{
variable len = strbytelen(buf), ch, p0 = 0, p1 = 0;
Line 3,359 ⟶ 4,067:
array_reverse(au);
% print(au);
print(strjoin(array_map(String_Type, &char, au), "") );</
Output: "ηψόκ νὴτ ὸπἀ ωζίρωνγ ὲΣ"
Line 3,367 ⟶ 4,075:
=={{header|SAS}}==
<
length a b $11;
a="I am Legend";
Line 3,373 ⟶ 4,081:
put a;
put b;
run;</
=={{header|Sather}}==
<
main is
s ::= "asdf";
Line 3,382 ⟶ 4,090:
-- current implementation does not handle multibyte encodings correctly
end;
end;</
=={{header|Scala}}==
Easy way:
<
Slightly less easy way:
<
Unicode-aware, method 1:
<
import java.text.{Normalizer,BreakIterator}
val norm = Normalizer.normalize(s, Normalizer.Form.NFKC) // waffle -> waffle (optional)
Line 3,403 ⟶ 4,111:
}
break(it, it.first).mkString
}</
{{out}}
<pre>scala> reverse("as⃝df̅")
Line 3,409 ⟶ 4,117:
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.
<
import java.lang.Character._
Line 3,438 ⟶ 4,146:
}
recurse(splitString(s), Nil)
}</
REPL on Windows doesn't handle Unicode, so I'll show the bytes instead:
<pre>
Line 3,449 ⟶ 4,157:
=={{header|Scheme}}==
<
(list->string (reverse (string->list s))))</
> (string-reverse "asdf")
Line 3,459 ⟶ 4,167:
=={{header|Sed}}==
<
/../! b
Line 3,476 ⟶ 4,184:
# Remove the newline markers
s/\n//g</
=={{header|Seed7}}==
Seed7 strings are encoded with UTF-32 therefore no special Unicode solution is necessary. The following demonstrates one way of reversing a string with a user-defined function.
<syntaxhighlight lang="ada"
const func string:
result
var string: result is "";
Line 3,495 ⟶ 4,203:
const proc: main is func
begin
writeln(
end func;</syntaxhighlight>The following demonstrates the use of the built-in 'reverse' function:<syntaxhighlight lang="ada" line="1">
$ include "seed7_05.s7i";
const proc: main is func
begin
writeln(reverse("Was it a cat I saw?"));
end func;
</syntaxhighlight>{{out}}
<pre>
was I tac a ti saW
</pre>
=={{header|Self}}==
In-place reversal:
<syntaxhighlight lang="self">'asdf' copyMutable reverse</syntaxhighlight>
=={{header|SenseTalk}}==
<syntaxhighlight lang="sensetalk">put "asdf" reversed -- reverse on the fly
set imp to "rumpelstiltskin"
reverse imp -- reverse in place
put imp
</syntaxhighlight>
{{out}}
<pre>
fdsa
nikstlitslepmur
</pre>
Line 3,506 ⟶ 4,237:
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.
<
reverse(list(1))[i] :=
let
range := - ((1 ... size(list)) - (size(list) + 1));
in
list[i] foreach i within range;</
=={{header|Sidef}}==
<
"résumé niño".reverse; # oñin émusér</
=={{header|Simula}}==
<
BEGIN
TEXT PROCEDURE REV(S); TEXT S;
Line 3,551 ⟶ 4,283:
OUTTEXT(REV(INP)); OUTIMAGE;
END
</syntaxhighlight>
{{out}}
<pre>
Line 3,557 ⟶ 4,289:
fdsa
</pre>
=={{header|Slate}}==
In-place reversal:
<syntaxhighlight lang
Non-destructive reversal:
<syntaxhighlight lang
=={{header|Smalltalk}}==
<syntaxhighlight lang
{{works with|Smalltalk/X}}
the above does inplace, destructive reverse. It is usually better to use
<syntaxhighlight lang
which returns a new string.
=={{header|SNOBOL4}}==
ASCII-only
<
end</
{{out}}
<pre>reverse</pre>
=={{header|Standard ML}}==
<
val string = "asdf";
val reversed = str_reverse string;</
=={{header|Stata}}==
Line 3,591 ⟶ 4,319:
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.
<
. di strreverse(s)
SIVERB ATIV AGNOL SRA
. scalar s="Ἐν ἀρχῇ ἐποίησεν ὁ θεὸς τὸν οὐρανὸν καὶ τὴν γῆν"
. di ustrreverse(s)
νῆγ νὴτ ὶακ νὸναρὐο νὸτ ςὸεθ ὁ νεσηίοπἐ ῇχρἀ νἘ</
=={{header|Stringle}}==
This inputs a string from the user and outputs its reverse. The <code>\</code> ''reverse'' operator reverses any string.
<syntaxhighlight lang="stringle">$ \$</syntaxhighlight>
=={{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:
{{works with|Swift|2.x+}}
<
return String(s.characters.reverse())
}
print(reverseString("asdf"))
print(reverseString("as⃝df̅"))</
{{works with|Swift|1.x}}
<
return String(reverse(s))
}
println(reverseString("asdf"))
println(reverseString("as⃝df̅"))</
{{out}}
<pre>
fdsa
f̅ds⃝a
</pre>
=={{header|Symsyn}}==
<syntaxhighlight lang="symsyn">
| reverse string
c : 'abcdefghijklmnopqrstuvwxyz'
d : ' '
c []
i
#c j
- j
if i < j
c.i d 1
c.j c.i 1
d c.j
- j
+ i
goif
endif
c []
</syntaxhighlight>
OR
<syntaxhighlight lang="symsyn">
c : 'abcdefghijklmnopqrstuvwxyz'
c []
$s
#c j
if j > 0
- j
+ c.j $s 1
goif
endif
$s []
</syntaxhighlight>
{{out}}
<pre>
abcdefghijklmnopqrstuvwxyz
zyxwvutsrqponmlkjihgfedcba
</pre>
=={{header|Tailspin}}==
<
templates reverse
'$:[ $... ] -> $(last..first:-1)...;' !
Line 3,631 ⟶ 4,409:
'as⃝df̅' -> reverse -> !OUT::write
</syntaxhighlight>
{{out}}
<pre>
Line 3,639 ⟶ 4,417:
=={{header|Tcl}}==
<
string reverse asdf</
=={{header|TI-83 BASIC}}==
Note: length( and sub( can be found in the catalog.
<
:For(I,1,length(Ans)-1
:sub(Ans,2I,1)+Ans
:End
:sub(Ans,1,I→Str1</
=={{header|TMG}}==
Unix TMG:
<syntaxhighlight lang="unixtmg">prog: parse(str);
str: smark any(!<<>>) scopy str/done = { 1 2 };
done: ;</syntaxhighlight>
=={{header|Tosh}}==
<syntaxhighlight lang="tosh">when flag clicked
ask "Say something..." and wait
set i to (length of answer)
set inv to ""
repeat until i = 0
set inv to (join (inv) (letter (i) of answer))
change i by -1
end
say inv</syntaxhighlight>
=={{header|Transd}}==
<syntaxhighlight lang="scheme">#lang transd
MainModule : {
_start: (lambda (with s "as⃝df̅"
(textout (reverse s))
// reversing user input
(textout "\nPlease, enter a string: ")
(textout "Input: " (reverse (read s)))
))
}</syntaxhighlight>
{{out}}
<pre>
̅fd⃝sa
Please, enter a string: Hello!
Input: !olleH
</pre>
=={{header|Turing}}==
Iterative solution, for character shovelers:
<syntaxhighlight lang="turing">function reverse (s : string) : string
var rs := ""
for i : 0 .. length (s) - 1
rs := rs + s (length (s) - i)
end for
result rs
end reverse
put
put reverse (reverse ("iterative example"))</syntaxhighlight>
{{out}}
<pre>
elpmaxe evitareti
iterative example
</pre>
Recursive solution, more natural in Turing:
<syntaxhighlight lang="turing">function reverse (s : string) : string
if s = "" then
result s
else
result reverse (s (2 .. *)) + s (1)
end if
end reverse
put reverse ("recursive example")
put reverse (reverse ("recursive example"))</syntaxhighlight>
{{out}}
<pre>
elpmaxe evisrucer
recursive example
</pre>
=={{header|TUSCRIPT}}==
<
SET input="was it really a big fat cat i saw"
SET reversetext=TURN (input)
PRINT "before: ",input
PRINT "after: ",reversetext</
{{out}}
<pre>
Line 3,683 ⟶ 4,516:
=={{header|UNIX Shell}}==
<
#!/bin/bash
str=abcde
Line 3,690 ⟶ 4,523:
echo $rev
</syntaxhighlight>
'''or'''
<
str='i43go1342iu 23iu4o 23iu14i324y 2i13'
rev <<< "$str"
#rev is not built-in function, though is in /usr/bin/rev
</syntaxhighlight>
=={{header|Unlambda}}==
Reverse the whole input:
<
=={{header|Ursala}}==
<
#cast %s
Line 3,711 ⟶ 4,544:
example = ~&x 'asdf'
verbose_example = reverse 'asdf'</
{{out}}
<pre>
Line 3,717 ⟶ 4,550:
</pre>
=={{
<
if (args.length < 2) {
stdout.printf ("Please, input a string.\n");
Line 3,729 ⟶ 4,562:
stdout.printf ("%s\n", str.str.strip ().reverse ());
return 0;
}</
=={{
===Non-recursive version===
<
' returns the reversed string
dim L as integer 'length of string
Line 3,744 ⟶ 4,577:
next
Reverse = newString
End Function</
===Recursive version===
<
'returns the reversed string
'do it recursively: cut the string in two, reverse these fragments and put them back together in reverse order
Line 3,759 ⟶ 4,592:
RReverse = RReverse(Right$(aString, L - M)) & RReverse(Left$(aString, M))
End If
End Function</
===Example dialogue===
<pre>
Line 3,774 ⟶ 4,607:
=={{header|VBScript}}==
{{works with|Windows Script Host|*}}
<syntaxhighlight lang="vbscript">
WScript.Echo StrReverse("asdf")
</syntaxhighlight>
=={{header|Vedit macro language}}==
This routine reads the text from current line, reverses it and stores the reversed string in text register 10:
<
for (BOL; !At_EOL; Char) {
Reg_Copy_Block(10, CP, CP+1, INSERT)
}</
This routine reverses the current line in-place:
<
while (!At_EOL) {
Block_Copy(EOL_pos-1, EOL_pos, DELETE)
}</
=={{header|Visual Basic}}==
{{works with|Visual Basic|6}}
<
=={{header|Visual Basic .NET}}==
Line 3,801 ⟶ 4,634:
Since the windows console may not support Unicode, the program can optionally redirect its output to a file.
<
Module Program
Line 3,857 ⟶ 4,690:
#End If
End Sub
End Module</
{{out|note=copied from Notepad}}
Line 3,874 ⟶ 4,707:
=={{header|Wart}}==
<
Wart doesn't support Unicode yet.
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">const list =
('
Hello world!
你好世界!
Salamu, Dunia!
こんにちは世界!
¡Hola Mundo!
Chào thế giới!
Hallo Welt!
')
fn main() {
for line in list.split('\n') {if line !='' {println(reverse_string(line))}}
}
fn reverse_string(word string) string {
return word.runes().reverse().string()
}</syntaxhighlight>
{{out}}
<pre>
!dlrow olleH
!界世好你
!ainuD ,umalaS
!界世はちにんこ
!odnuM aloH¡
!iớig ếht oàhC
!tleW ollaH
</pre>
=={{header|Wren}}==
{{libheader|Wren-str}}
{{libheader|Wren-upc}}
<syntaxhighlight lang="wren">import "./str" for Str
import "./upc" for Graphemes
for (word in ["asdf", "josé", "møøse", "was it a car or a cat I saw", "😀🚂🦊"]) {
System.print(Str.reverse(word))
}
for (word in ["as⃝df̅", "ℵΑΩ 駱駝道 🤔 🇸🇧 🇺🇸 🇬🇧 👨👩👧👦🆗🗺"]) {
System.print(Graphemes.new(word).toList[-1..0].join())
}</syntaxhighlight>
{{out}}
<pre>
fdsa
ésoj
esøøm
was I tac a ro rac a ti saw
🦊🚂😀
f̅ds⃝a
🗺🆗👨👩👧👦 🇬🇧 🇺🇸 🇸🇧 🤔 道駝駱 ΩΑℵ
</pre>
=={{header|Wortel}}==
<
@rev "abc" ; returns "cba"
; or the same thing using a pointer expression
!~r "abc"</
=={{header|XBS}}==
Using the standard library
<syntaxhighlight lang="xbs">log(string.reverse("Hello"))</syntaxhighlight>
{{out}}
<pre>
olleH
</pre>
Using [[JavaScript]] methods
<syntaxhighlight lang="xbs">log("Hello"->split("")->reverse()->join(""));</syntaxhighlight>
{{out}}
<pre>
olleH
</pre>
Using a custom method
<syntaxhighlight lang="xbs">func ReverseString(String){
set Final = "";
for(i=?String-1;0;-1){
Final+=String[i];
}
send Final;
}
log(ReverseString("Hello"));</syntaxhighlight>
{{out}}
<pre>
elloH
</pre>
=={{header|XPL0}}==
<
string 0; \use zero-terminated strings, instead of MSb terminated
Line 3,907 ⟶ 4,823:
Text(0, RevStr("abc")); CrLf(0);
Text(0, RevStr("Able was I ere I saw Elba.")); CrLf(0);
]</
Output:
Line 3,919 ⟶ 4,835:
=={{header|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.
<
=={{header|Z80 Assembly}}==
This method uses the stack as a temporary store to reverse the order of characters in a string, and self-modifying code to restore the loop counter.
<syntaxhighlight lang="z80">PrintChar equ $BB5A ;Amstrad CPC bios call
Terminator equ 0 ;null terminator for strings
org $8000
ld hl, StringA
call ReverseString
ld hl, StringA
call PrintString
ret ;return to basic
StringA:
byte "12345678",0
;;;; SUBROUTINES
GetStringLength:
;HL = STRING. RETURNS LENGTH IN B. LENGTH IS ONE-INDEXED AND DOES NOT INCLUDE TERMINATOR.
ld b,0 ;clear B
loop_getStringLength:
ld a,(hl) ;read the next char
cp Terminator ;is it the terminator?
ret z ;if so, exit
inc hl ;point HL to next character
inc b ;increase tally
jr loop_getStringLength ;repeat
ReverseString:
;reverse the order of letters in a text string.
;e.g. "ABCD" -> "DCBA"
;the terminator stays put.
;INPUT: HL = SOURCE ADDRESS OF STRING
push de
push hl
push hl
call GetStringLength
pop hl
pop de ;LD DE,HL
LD a,b ;LOAD B INTO A
LD (SMC_ReverseString+1),a ;STORE IT LATER IN THE CODE SO WE CAN RETRIEVE IT.
; TO RECAP, BOTH HL AND DE POINT TO THE BEGINNING OF THE STRING WE WANT TO REVERSE. B EQUALS THE LENGTH OF THE STRING.
; B HAS BEEN BACKED UP WITHOUT USING THE STACK BY STORING IT AS THE OPERAND OF A LATER INSTRUCTION THAT LOADS B WITH A NUMERIC VALUE.
; PUSH BC WOULD NOT HAVE WORKED SINCE THE PROGRAM NEEDS TO PUSH EACH LETTER OF THE STRING DURING THE LOOP.
LOOP_REVERSESTRING_PUSH:
;start at the beginning of the string and push each letter in it, except the terminator.
ld a,(de)
push af
inc de
djnz LOOP_REVERSESTRING_PUSH
SMC_ReverseString:
ld b,$42 ;LETS US PRESERVE B WITHOUT PUSHING IT. THE $42 IS OVERWRITTEN WITH THE STRING'S LENGTH.
LOOP_REVERSESTRING_POP:
;Starting at the beginning of the string, pop A off the stack and store it into the string. This puts the letters back in the reverse
; order.
pop af
ld (hl),a
inc hl
djnz LOOP_REVERSESTRING_POP
pop de
ret</syntaxhighlight>
{{out}}
<pre>
87654321
</pre>
=={{header|zkl}}==
Line 3,939 ⟶ 4,929:
{{omit from|Openscad}}
[[Wikipedia::https://en.wikipedia.org/wiki/Comparison_of_programming_languages_%28string_functions%29#reverse]]
=={{header|Zoea}}==
<syntaxhighlight lang="zoea">
program: reverse_string
input: xyzzy
output: yzzyx
</syntaxhighlight>
=={{header|Zoea Visual}}==
[http://zoea.co.uk/examples/zv-rc/Reverse_string.png Reverse string]
=={{header|Zig}}==
We can use `.*` to dereference a literal string pointer to an array, and use `std.mem.reverse` to reverse the slice of that array in-place:
<syntaxhighlight lang="zig">
var s = "socat".*;
std.mem.reverse(u8, &s);
</syntaxhighlight>
or:
<syntaxhighlight lang="zig">
var s = "socat".*;
std.mem.reverse(u8, s[0..]);
</syntaxhighlight>
String `s` now becomes `"tacos"`.
Tested on version 0.9.0. Reference: [https://ziglang.org/documentation/0.9.0/#String-Literals-and-Unicode-Code-Point-Literals].
|