Reverse a string: Difference between revisions
(Add SenseTalk implementation) |
|||
Line 2,272: | Line 2,272: | ||
"oof"</lang> |
"oof"</lang> |
||
=={{header|Mathematica}}== |
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
||
<lang mathematica>StringReverse["asdf"]</lang> |
<lang mathematica>StringReverse["asdf"]</lang> |
||
Revision as of 09:51, 14 August 2021
You are encouraged to solve this task according to the task description, using any language you may know.
- Task
Take a string and reverse it.
For example, "asdf" becomes "fdsa".
- Extra credit
Preserve Unicode combining characters.
For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa".
- Metrics
- Counting
- Word frequency
- Letter frequency
- Jewels and stones
- I before E except after C
- Bioinformatics/base count
- Count occurrences of a substring
- Count how many vowels and consonants occur in a string
- Remove/replace
- XXXX redacted
- Conjugate a Latin verb
- Remove vowels from a string
- String interpolation (included)
- Strip block comments
- Strip comments from a string
- Strip a set of characters from a string
- Strip whitespace from a string -- top and tail
- Strip control codes and extended characters from a string
- Anagrams/Derangements/shuffling
- Word wheel
- ABC problem
- Sattolo cycle
- Knuth shuffle
- Ordered words
- Superpermutation minimisation
- Textonyms (using a phone text pad)
- Anagrams
- Anagrams/Deranged anagrams
- Permutations/Derangements
- Find/Search/Determine
- ABC words
- Odd words
- Word ladder
- Semordnilap
- Word search
- Wordiff (game)
- String matching
- Tea cup rim text
- Alternade words
- Changeable words
- State name puzzle
- String comparison
- Unique characters
- Unique characters in each string
- Extract file extension
- Levenshtein distance
- Palindrome detection
- Common list elements
- Longest common suffix
- Longest common prefix
- Compare a list of strings
- Longest common substring
- Find common directory path
- Words from neighbour ones
- Change e letters to i in words
- Non-continuous subsequences
- Longest common subsequence
- Longest palindromic substrings
- Longest increasing subsequence
- Words containing "the" substring
- Sum of the digits of n is substring of n
- Determine if a string is numeric
- Determine if a string is collapsible
- Determine if a string is squeezable
- Determine if a string has all unique characters
- Determine if a string has all the same characters
- Longest substrings without repeating characters
- Find words which contains all the vowels
- Find words which contains most consonants
- Find words which contains more than 3 vowels
- Find words which first and last three letters are equals
- Find words which odd letters are consonants and even letters are vowels or vice_versa
- Formatting
- Substring
- Rep-string
- Word wrap
- String case
- Align columns
- Literals/String
- Repeat a string
- Brace expansion
- Brace expansion using ranges
- Reverse a string
- Phrase reversals
- Comma quibbling
- Special characters
- String concatenation
- Substring/Top and tail
- Commatizing numbers
- Reverse words in a string
- Suffixation of decimal numbers
- Long literals, with continuations
- Numerical and alphabetical suffixes
- Abbreviations, easy
- Abbreviations, simple
- Abbreviations, automatic
- Song lyrics/poems/Mad Libs/phrases
- Mad Libs
- Magic 8-ball
- 99 Bottles of Beer
- The Name Game (a song)
- The Old lady swallowed a fly
- The Twelve Days of Christmas
- Tokenize
- Text between
- Tokenize a string
- Word break problem
- Tokenize a string with escaping
- Split a character string based on change of character
- Sequences
0815
This program reverses each line of its input. <lang 0815>}:r: Start reader loop.
!~>& Push a character to the "stack". <:a:=- Stop reading on newline.
^:r: @> Rotate the newline to the end and enqueue a sentinel 0. {~ Dequeue and rotate the first character into place. }:p:
${~ Print the current character until it's 0.
^:p:
- r: Read again.</lang>
- Output:
<lang bash>echo -e "foo\nbar" | 0815 rev.0 oof rab</lang>
11l
<lang 11l>reversed(string)</lang>
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. <lang 360asm>* Reverse a string 21/05/2016 REVERSE CSECT
USING REVERSE,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 " MVC TMP(L'C),C tmp=c LA R8,C @c[1] LA R9,TMP+L'C-1 @tmp[n-1] LA R6,1 i=1 LA R7,L'C n=length(c)
LOOPI CR R6,R7 do i=1 to n
BH ELOOPI leave i MVC 0(1,R8),0(R9) substr(c,i,1)=substr(tmp,n-i+1,1) LA R8,1(R8) @c=@c+1 BCTR R9,0 @tmp=@tmp-1 LA R6,1(R6) i=i+1 B LOOPI next i
ELOOPI XPRNT C,L'C print c
L R13,4(0,R13) epilog LM R14,R12,12(R13) " XR R15,R15 " BR R14 exit
C DC CL12'edoC attesoR' TMP DS CL12
REGEQU END REVERSE</lang>
- Output:
Rosetta Code
This second example uses MVCIN introduced in S/370 architecture. <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</lang>
- Output:
Rosetta Code
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 $
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 arrayrev
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.
<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</lang>
8th
In 8th strings are UTF-8 and the language retains characters per-se: <lang forth> "abc" s:rev </lang>
- Output:
"cba"
ACL2
<lang Lisp>(reverse "hello")</lang>
ACL2 does not support unicode.
ActionScript
<lang ActionScript>function reverseString(string:String):String { var reversed:String = new String(); for(var i:int = string.length -1; i >= 0; i--) reversed += string.charAt(i); return reversed; }
function reverseStringCQAlternative(string:String):String { return string.split().reverse().join(); }</lang>
Ada
<lang ada>with Ada.Text_IO; use Ada.Text_IO;
procedure Reverse_String is
function Reverse_It (Item : String) return String is Result : String (Item'Range); begin for I in Item'range loop Result (Result'Last - I + Item'First) := Item (I); end loop; return Result; end Reverse_It;
begin
Put_Line (Reverse_It (Get_Line));
end Reverse_String;</lang>
Agda
Using the Agda standard library, version 0.6. <lang agda2>module reverse_string where
open import Data.String open import Data.List
reverse_string : String → String reverse_string s = fromList (reverse (toList s))</lang>
Aime
<lang aime>o_(b_reverse("Hello, World!"), "\n");</lang>
ALGOL 68
<lang algol68>PROC reverse = (REF STRING s)VOID:
FOR i TO UPB s OVER 2 DO CHAR c = s[i]; s[i] := s[UPB s - i + 1]; s[UPB s - i + 1] := c OD;
main: (
STRING text := "Was it a cat I saw"; reverse(text); print((text, new line))
)</lang>
- Output:
was I tac a ti saW
Apex
<lang java> String str = 'Hello World!'; str = str.reverse(); system.debug(str); </lang>
APL
<lang apl> ⌽'asdf' fdsa</lang>
AppleScript
<lang AppleScript>reverseString("Hello World!")
on reverseString(str)
reverse of characters of str as string
end reverseString</lang>
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 {""}
(or just ""
) before doing an operation like this, in case they've been set to something else elsewhere in the script:
<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</lang>
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:
<lang AppleScript>-- Using either a generic foldr(f, a, xs)
-- reverse1 :: [a] -> [a] on reverse1(xs)
script rev on |λ|(a, x) a & x end |λ| end script if class of xs is text then foldr(rev, {}, xs) as text else foldr(rev, {}, xs) end if
end reverse1
-- or the built-in reverse method for lists
-- reverse2 :: [a] -> [a] on reverse2(xs)
if class of xs is text then (reverse of characters of xs) as text else reverse of xs end if
end reverse2
-- TESTING reverse1 and reverse2 with same string and list ---------------------------------------------------------------------------
on run
script test on |λ|(f) map(f, ["Hello there !", {1, 2, 3, 4, 5}]) end |λ| end script map(test, [reverse1, reverse2])
end run
-- GENERIC FUNCTIONS ---------------------------------------------------------------------------
-- foldr :: (a -> b -> a) -> a -> [b] -> a on foldr(f, startValue, xs)
tell mReturn(f) set v to startValue set lng to length of xs repeat with i from lng to 1 by -1 set v to |λ|(v, item i of xs, i, xs) end repeat return v end tell
end foldr
-- map :: (a -> b) -> [a] -> [b] on map(f, xs)
tell mReturn(f) set lng to length of xs set lst to {} repeat with i from 1 to lng set end of lst to |λ|(item i of xs, i, xs) end repeat return lst end tell
end map
-- Lift 2nd class handler function into 1st class script wrapper -- mReturn :: Handler -> Script on mReturn(f)
if class of f is script then f else script property |λ| : f end script end if
end mReturn</lang>
- Output:
<lang AppleScript>{{"! ereht olleH", {5, 4, 3, 2, 1}},
{"! ereht olleH", {5, 4, 3, 2, 1}}}</lang>
Applesoft BASIC
<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</lang>
Arturo
<lang rebol>str: "Hello World"
print reverse str</lang>
- Output:
dlroW olleH
AutoHotkey
- "Normal" version:
<lang AutoHotkey>MsgBox % reverse("asdf")
reverse(string) {
Loop, Parse, string reversed := A_LoopField . reversed Return reversed
}</lang>
- A ''much'' slower version:
<lang AHK>Reverse(String){ ; credit to Rseding91
If (A_IsUnicode){ SLen := StrLen(String) * 2 VarSetCapacity(RString,SLen) Loop,Parse,String NumPut(Asc(A_LoopField),RString,SLen-(A_Index * 2),"UShort") } Else { SLen := StrLen(String) VarSetCapacity(RString,SLen) Loop,Parse,String NumPut(Asc(A_LoopField),RString,SLen-A_Index,"UChar") } VarSetCapacity(RString,-1) Return RString
}</lang>
AutoIt
<lang AutoIt>#AutoIt Version: 3.2.10.0 $mystring="asdf" $reverse_string = "" $string_length = StringLen($mystring)
For $i = 1 to $string_length
$last_n_chrs = StringRight($mystring, $i) $nth_chr = StringTrimRight($last_n_chrs, $i-1) $reverse_string= $reverse_string & $nth_chr
Next
MsgBox(0, "Reversed string is:", $reverse_string)</lang>
Avail
<lang Avail>"asfd" reversed</lang>
AWK
<lang awk>function reverse(s) {
p = "" for(i=length(s); i > 0; i--) { p = p substr(s, i, 1) } return p
}
BEGIN {
print reverse("edoCattesoR")
}</lang>
- Recursive
<lang awk>function reverse(s ,l) {
l = length(s) return l < 2 ? s:( substr(s,l,1) reverse(substr(s,1,l-1)) )
}
BEGIN {
print reverse("edoCattesoR")
}</lang>
- using split, then joining in front
<lang awk># Usage: awk -f reverse.awk -v s=Rosetta
function rev(s, i,len,a,r) {
len = split(s, a, "") #for (i in a) r = a[i] r # may not work - order is not guaranteed ! for (i=1; i<=len; i++) r = a[i] r return r
} BEGIN {
if(!s) s = "Hello, world!" print s, "<-->", rev(s)
} </lang>
- Output:
Rosetta <--> attesoR
Babel
This example will handle UTF-8 encoded Unicode but doesn't handle combining characters. <lang babel>strrev: { str2ar ar2ls reverse ls2lf ar2str }</lang>
- 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
- reverse - this operator reverses a linked-list
- ls2lf - this operator undoes the effect of ar2ls
- ar2str - this operator undoes the effect of str2ar
BaCon
<lang freebasic>OPTION UTF8 TRUE s$ = "asdf" PRINT REVERSE$(s$)</lang>
Unicode preservation works in BaCon 3.6 and higher.
BASIC
<lang qbasic>function reverse$(a$)
b$ = "" for i = 1 to len(a$) b$ = mid$(a$, i, 1) + b$ next i reverse$ = b$
end function</lang>
IS-BASIC
<lang IS-BASIC>100 INPUT PROMPT "String: ":TX$ 120 LET REV$="" 130 FOR I=LEN(TX$) TO 1 STEP-1 140 LET REV$=REV$&TX$(I) 150 NEXT 160 PRINT REV$</lang>
Sinclair ZX81 BASIC
<lang basic>10 INPUT S$ 20 LET T$="" 30 FOR I=LEN S$ TO 1 STEP -1 40 LET T$=T$+S$(I) 50 NEXT I 60 PRINT T$</lang>
Batch File
<lang dos>@echo off setlocal enabledelayedexpansion call :reverse %1 res echo %res% goto :eof
- reverse
set str=%~1 set cnt=0
- loop
if "%str%" equ "" ( goto :eof ) set chr=!str:~0,1! set str=%str:~1% set %2=%chr%!%2! goto loop</lang>
BBC BASIC
<lang bbcbasic> PRINT FNreverse("The five boxing wizards jump quickly")
END DEF FNreverse(A$) LOCAL B$, C% FOR C% = LEN(A$) TO 1 STEP -1 B$ += MID$(A$,C%,1) NEXT = B$</lang>
Befunge
Reads a line from stdin and write the reverse to stdout. Can be made to repeat indefinitely by removing the final @ command.
<lang befunge>55+~>:48>*#8\#4`#:!#<#~_$>:#,_@</lang>
Bracmat
<lang bracmat> ( reverse
= L x . :?L & @( !arg : ? ( %?x & utf$!x & !x !L:?L & ~` ) ? ) | str$!L )
& out$reverse$Ελληνικά</lang>
- Output:
άκινηλλΕ
Brainf***
<lang bf>[-]>,[>,]<[.<]</lang> Another solution: <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 +++++ +++++ +++ . --- .</lang>
Brat
<lang brat>p "olleh".reverse #Prints "hello"</lang>
Burlesque
<lang burlesque> "Hello, world!"<- </lang>
C
<lang c>#include <stdio.h>
- include <stdlib.h>
- include <locale.h>
- include <wchar.h>
const char *sa = "abcdef"; const char *su = "as⃝df̅"; /* Should be in your native locale encoding. Mine is UTF-8 */
int is_comb(wchar_t c) { if (c >= 0x300 && c <= 0x36f) return 1; if (c >= 0x1dc0 && c <= 0x1dff) return 1; if (c >= 0x20d0 && c <= 0x20ff) return 1; if (c >= 0xfe20 && c <= 0xfe2f) return 1; return 0; }
wchar_t* mb_to_wchar(const char *s) { wchar_t *u; size_t len = mbstowcs(0, s, 0) + 1; if (!len) return 0;
u = malloc(sizeof(wchar_t) * len); mbstowcs(u, s, len); return u; }
wchar_t* ws_reverse(const wchar_t* u) { size_t len, i, j; wchar_t *out; for (len = 0; u[len]; len++); out = malloc(sizeof(wchar_t) * (len + 1)); out[len] = 0; j = 0; while (len) { for (i = len - 1; i && is_comb(u[i]); i--); wcsncpy(out + j, u + i, len - i); j += len - i; len = i; } return out; }
char *mb_reverse(const char *in) { size_t len; char *out; wchar_t *u = mb_to_wchar(in); wchar_t *r = ws_reverse(u); len = wcstombs(0, r, 0) + 1; out = malloc(len); wcstombs(out, r, len); free(u); free(r); return out; }
int main(void) { setlocale(LC_CTYPE, "");
printf("%s => %s\n", sa, mb_reverse(sa)); printf("%s => %s\n", su, mb_reverse(su)); return 0; }</lang>
- Output:
abcdef => fedcba as⃝df̅ => f̅ds⃝a
<lang c>#include <glib.h> gchar *srev (const gchar *s) {
if (g_utf8_validate(s,-1,NULL)) { return g_utf8_strreverse (s,-1);
} } // main int main (void) {
const gchar *t="asdf"; const gchar *u="as⃝df̅"; printf ("%s\n",srev(t)); printf ("%s\n",srev(u)); return 0;
}</lang>
C#
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: <lang csharp>static string ReverseString(string input) {
char[] inputChars = input.ToCharArray(); Array.Reverse(inputChars); return new string(inputChars);
}</lang>
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: <lang csharp>using System.Linq;
// ...
return new string(input.Reverse().ToArray());
// ...</lang>
Version supporting combining characters:
System.Globalization.StringInfo provides a means of separating a string into individual graphemes. <lang csharp>public string ReverseElements(string s) {
// In .NET, a text element is series of code units that is displayed as one character, and so reversing the text // elements of the string correctly handles combining character sequences and surrogate pairs. var elements = System.Globalization.StringInfo.GetTextElementEnumerator(s); return string.Concat(AsEnumerable(elements).OfType<string>().Reverse());
}
// Wraps an IEnumerator, allowing it to be used as an IEnumerable. public IEnumerable AsEnumerable(IEnumerator enumerator) {
while (enumerator.MoveNext()) yield return enumerator.Current;
}</lang>
C++
<lang cpp>#include <iostream>
- include <string>
- include <algorithm>
int main() {
std::string s; std::getline(std::cin, s); std::reverse(s.begin(), s.end()); // modifies s std::cout << s << std::endl; return 0;
}</lang>
Caché ObjectScript
USER>Write $Reverse("Hello, World") dlroW ,olleH
Ceylon
<lang Ceylon> shared void run() {
while(true) { process.write("> "); String? text = process.readLine(); if (is String text) { print(text.reversed); } else { break; } }
} </lang>
Clipper
Works with versions since 5, because LOCAL variables and the += operator was not implemented before. <lang Clipper>FUNCTION Reverse(sIn)
LOCAL sOut := "", i FOR i := Len(sIn) TO 1 STEP -1 sOut += Substr(sIn, i, 1) NEXT
RETURN sOut</lang>
Clojure
A Simple implementation with the magic of "conj" function
<lang lisp> (defn reverse-string [s]
"Returns a string with all characters in reverse" (apply str (reduce conj '() s)))
</lang>
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) <lang lisp>(defn str-reverse [s] (apply str (reverse s)))</lang>
b) <lang lisp>(apply str (interpose " " (reverse (.split "the quick brown fox" " "))))</lang>
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. <lang lisp>(defn combining? [c]
(let [type (Character/getType c)] ;; currently hardcoded to the types taken from the sample string (or (= type 6) (= type 7))))
(defn group
"Group normal characters with their combining characters" [chars] (cond (empty? chars) chars
(empty? (next chars)) (list chars) :else (let [dres (group (next chars))] (cond (combining? (second chars)) (cons (cons (first chars) (first dres)) (rest dres)) :else (cons (list (first chars)) dres)))))
(defn str-reverse
"Unicode-safe string reverse" [s] (apply str (apply concat (reverse (group s)))))</lang>
- Output:
user=> s "as⃝df̅" user=> (str-reverse s) "f̅ds⃝a"[ user=> (str-reverse (str-reverse s)) "as⃝df̅" user=>
COBOL
<lang cobol>FUNCTION REVERSE('QWERTY')</lang>
CoffeeScript
<lang javascript>"qwerty".split("").reverse().join ""</lang>
ColdFusion
You can reverse anything that can be written to the document in hashmarks (i.e. strings, numbers, now( ), etc.). <lang cfm><cfset myString = "asdf" /> <cfset myString = reverse( myString ) /></lang>
Common Lisp
<lang lisp>(reverse my-string)</lang>
Component Pascal
BlackBox Component Builder <lang oberon2> MODULE BbtReverseString; IMPORT StdLog;
PROCEDURE ReverseStr(str: ARRAY OF CHAR): POINTER TO ARRAY OF CHAR; VAR top,middle,i: INTEGER; c: CHAR; rStr: POINTER TO ARRAY OF CHAR; BEGIN NEW(rStr,LEN(str$) + 1); top := LEN(str$) - 1; middle := (top - 1) DIV 2; FOR i := 0 TO middle DO rStr[i] := str[top - i]; rStr[top - i] := str[i]; END; IF ODD(LEN(str$)) THEN rStr[middle + 1] := str[middle + 1] END; RETURN rStr; END ReverseStr;
PROCEDURE Do*;
VAR
x: CHAR;
BEGIN
StdLog.String("'asdf' reversed:> ");StdLog.String(ReverseStr("asdf"));StdLog.Ln
END Do;
END BbtReverseString.
</lang>
Execute: ^Q BbtReverseString.Do
- Output:
'asdf' reversed:> fdsa
Cowgol
<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]));</lang>
- Output:
Reverse
Crystal
<lang ruby># version 0.21.1
strings = ["asdf", "as⃝df̅"] strings.each do |s|
puts "#{s} -> #{s.reverse}"
end</lang>
- Output:
asdf -> fdsa as⃝df̅ -> f̅ds⃝a
D
<lang d>void main() { import std.range, std.conv;
string s1 = "hello"; // UTF-8 assert(s1.retro.text == "olleh");
wstring s2 = "hello"w; // UTF-16 assert(s2.retro.wtext == "olleh"w);
dstring s3 = "hello"d; // UTF-32 assert(s3.retro.dtext == "olleh"d);
// without using std.range: dstring s4 = "hello"d; assert(s4.dup.reverse == "olleh"d); // simple but inefficient (copies first, then reverses) }</lang>
Dart
Since Dart strings are sequences of UTF-16 code units, it would not be sufficient to simply reverse the characters in strings, as this would not work with UTF-16 surrogate pairs (pairs of UTF-16 code units that represent single characters 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:
<lang dart>String reverse(String s) => new String.fromCharCodes(s.runes.toList().reversed);</lang>
A more complete example with unit tests would look like this:
<lang dart>import 'package:unittest/unittest.dart';
String reverse(String s) => new String.fromCharCodes(s.runes.toList().reversed);
main() {
group("Reverse a string -", () { test("Strings with ASCII characters are reversed correctly.", () { expect(reverse("hello, world"), equals("dlrow ,olleh")); }); test("Strings with non-ASCII BMP characters are reversed correctly.", () { expect(reverse("\u4F60\u4EEC\u597D"), equals("\u597D\u4EEC\u4F60")); }); test("Strings with non-BMP characters are reversed correctly.", () { expect(reverse("hello, \u{1F310}"), equals("\u{1F310} ,olleh")); }); });
}</lang>
DBL
<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
</lang>
Dc
Reversing "Hello world!" which is "22405534230753963835153736737" in Dc's numerical string representaion.
Due to using "~" this example needs GNU Dc or OpenBSD Dc.
<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</lang>
!dlrow olleH
Delphi
<lang Delphi>function ReverseString(const InString: string): string; var
i: integer;
begin
for i := Length(InString) downto 1 do Result := Result + InString[i];
end;</lang> You could also use this RTL function Introduced in Delphi 6: <lang Delphi>StrUtils.ReverseString</lang>
Another alternative. <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;</lang> All versions has the same perfomance, then StrUtils is recomended.
DWScript
See Delphi.
Dyalect
<lang dyalect>let str = "asdf"
func String.reverse() {
var cs = [] let len = this.len() for n in 1..len { cs.add(this[len - n]) } String(values: cs)
}
str.reverse()</lang>
Déjà Vu
<lang dejavu>!print concat chars "Hello"</lang>
- Output:
olleH
E
<lang e>pragma.enable("accumulator") def reverse(string) {
return accum "" for i in (0..!(string.size())).descending() { _ + string[i] }
}</lang>
EchoLisp
<lang lisp> (define (string-reverse string)
(list->string (reverse (string->list string))))
(string-reverse "ghij")
→ jihg
(string-reverse "un roc lamina l animal cornu")
→ unroc lamina l animal cor nu
</lang>
EGL
<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</lang>
Eiffel
<lang eiffel>class
APPLICATION
create
make
feature
make -- Demonstrate string reversal. do my_string := "Hello World!" my_string.mirror print (my_string) end my_string: STRING -- Used for reversal
end</lang>
- Output:
!dlroW olleH
Ela
<lang ela>reverse_string str = rev len str
where len = length str rev 0 str = "" rev n str = toString (str : nn) +> rev nn str where nn = n - 1
reverse_string "Hello"</lang>
- Output:
"olleH"
Another approach is to covert a string to a list, reverse a list and then convert it back to a string:
<lang ela>open string fromList <| reverse <| toList "Hello" ::: String</lang>
Elena
ELENA 4.x: <lang elena>import system'routines; import extensions; import extensions'text;
extension extension {
reversedLiteral() = self.toArray().sequenceReverse().summarize(new StringWriter());
}
public program() {
console.printLine("Hello World".reversedLiteral())
}</lang>
- Output:
dlroW olleH
Elixir
Elixir handles Unicode graphemes correctly by default. <lang elixir> IO.puts (String.reverse "asdf") IO.puts (String.reverse "as⃝df̅") </lang>
- Output:
fdsa f̅ds⃝a
Elm
<lang elm>-- The import on the next line provides the reverse string -- functionality satisfying the rosettacode.org task description. import String exposing (reverse)
-- The rest is fairly boilerplate code demonstrating -- interactively that the reverse function works. import Html exposing (Html, Attribute, text, div, input) import Html.Attributes exposing (placeholder, value, style) import Html.Events exposing (on, targetValue) import Html.App exposing (beginnerProgram)
main = beginnerProgram { model = "", view = view, update = update }
update newStr oldStr = newStr
view : String -> Html String view forward =
div [] ([ input [ placeholder "Enter a string to be reversed." , value forward , on "input" targetValue , myStyle ] [] ] ++ [ let backward = reverse forward in div [ myStyle] [text backward] ])
myStyle : Attribute msg myStyle =
style [ ("width", "100%") , ("height", "20px") , ("padding", "5px 0 0 5px") , ("font-size", "1em") , ("text-align", "left") ]</lang>
Link to live demo: http://dc25.github.io/reverseStringElm/
Emacs Lisp
<lang lisp>(reverse "Hello World")</lang>
- Output:
"dlroW olleH"
Erlang
<lang erlang>1> lists:reverse("reverse!"). "!esrever"</lang> 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. <lang erlang>reverse(Bin) ->
Size = size(Bin)*8, <<T:Size/integer-little>> = Bin, <<T:Size/integer-big>>.</lang>
- Output:
1> test:reverse(<<"hello">>). <<"olleh">>
ERRE
<lang ERRE> PROGRAM REVERSE_STRING
PROCEDURE REVERSE(A$->R$)
LOCAL I% R$="" FOR I=1 TO LEN(A$) DO R$=MID$(A$,I,1)+R$ END FOR
END PROCEDURE
BEGIN
A$="THE FIVE BOXING WIZARDS JUMP QUICKLY" REVERSE(A$->R$) PRINT(R$)
END PROGRAM </lang>
Euler Math Toolbox
<lang Euler Math Toolbox> >function strrev (s) := chartostr(fliplr(strtochar(s))) >strrev("This is a test!")
!tset a si sihT
</lang>
Euphoria
<lang euphoria> include std/sequence.e printf(1, "%s\n", {reverse("abcdef") }) </lang>
Explore
The Scratch solution, which requires making variables named "i" and "inv" first, works, unmodified:
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:
https://i.ibb.co/4pM9G8b/Reverse-a-string-in-Explore-using-a-special-block.png
Ezhil
<lang Ezhil>
- இந்த நிரல் தரப்படும் சரம் ஒன்றைத் தலைகீழாகத் திருப்பி அச்சிடும்
- உதாரணமாக "abc" என்ற சரம் தரப்பட்டால் அதனைத் திருப்பி "cba" என அச்சிடும்
- "எழில்" மொழியின்மூலம் இரண்டு வகைகளில் இதனைச் செய்யலாம். இரண்டு உதாரணங்களும் இங்கே தரப்பட்டுள்ளன
நிரல்பாகம் திருப்புக (சரம்1)
## முதல் வகை
சரம்2 = ""
@( சரம்1 இல் இ) ஒவ்வொன்றாக சரம்2 = இ + சரம்2 முடி
பின்கொடு சரம்2
முடி
நிரல்பாகம் மீண்டும்திருப்புக (சரம்1)
## இரண்டாம் வகை சரநீளம் = len(சரம்1) சரம்2 = ""
@(எண் = 0, எண் < சரநீளம், எண் = எண் + 1) ஆக
சரம்2 = எடு(சரம்1, எண்) + சரம்2
முடி
பின்கொடு சரம்2
முடி
அ = உள்ளீடு("ஓர் எழுத்துச் சரத்தைத் தாருங்கள் ")
பதிப்பி "நீங்கள் தந்த எழுத்துச் சரம்" அ
பதிப்பி "அதனை முதல் வகையில் திருப்பியுள்ளோம்: " திருப்புக(அ)
பதிப்பி "வேறொரு வகையில் திருப்பியுள்ளோம்: " மீண்டும்திருப்புக(அ)
</lang>
F#
The function
<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 ""
</lang>
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. <lang fsharp> printfn "%s" (strRev "as⃝df̅") printfn "%s" (strRev "Nigel") </lang>
- Output:
f̅ds⃝a legiN
Factor
A string is a sequence and there is a default reverse implementation for those.
<lang factor>"hello" reverse</lang>
string-reverse
preserves graphemes:
<lang factor>"as⃝df̅" string-reverse "f̅ds⃝a" = .</lang>
FALSE
This solution does not take into account combination characters: <lang false>1_ [^$1_=~][]#% [$1_=~][,]#</lang> This solution does take into account combination characters (except for half-marks): <lang false>1_ [^$1_=~][
$$767>\879\>& 1ø$7615>\7620\>&| 1ø$8399>\8428\>&| [\]?
]#% [$1_=~][,]#</lang>
Fancy
<lang fancy>"hello world!" reverse</lang>
FBSL
A slow way <lang qbasic>Function StrRev1(ByVal $p1) dim $b = "" REPEAT len(p1) b = b & RIGHT(p1,1) p1 = LEFT(p1,LEN(p1)-1) END REPEAT return b End Function </lang>
A much faster (twice at least) way <lang qbasic>Function StrRev2(ByVal $p1) dim $b = "", %i for i = len(p1) DOWNTO 1 b = b & MID(p1,i,1) next return b End Function</lang>
An even faster way using PEEK, POKE, double-calls and quantity-in-hand <lang qbasic>Function StrRev3( $s ) FOR DIM x = 1 TO LEN(s) \ 2 PEEK(@s + LEN - x, $1) POKE(@s + LEN - x, s{x})(@s + x - 1, PEEK) NEXT RETURN s end function </lang>
An even faster way using the DynC (Dynamic C) mode <lang c>DynC StringRev($theString) As String
void rev(char *str) {
int len = strlen(str); char *HEAD = str; char *TAIL = str + len - 1; char temp; int i; for ( i = 0; i <= len / 2; i++, HEAD++, TAIL--) { temp = *HEAD; *HEAD = *TAIL; *TAIL = temp; }
} char *main(char* theString) { rev(theString); return theString; }
End DynC</lang>
Using DynASM, the Dynamic Assembler mode. <lang asm>DYNASM RevStr(BYVAL s AS STRING) AS STRING
// get length of string // divide by two // setup pointers to head and tail // iterate from 1 to (length \ 2) // swap head with tail // increment head pointer // decrement tail pointer
ENTER 0, 0 // = PUSH EBP: MOV EBP, ESP PUSH EBX // by Windows convention EBX, EDI, ESI must be saved before modification MOV EAX, s // get string pointer MOV ECX, EAX // duplicate it .WHILE BYTE PTR [ECX] <> 0
INC ECX // propagate to tail
.WEND MOV EDX, ECX // duplicate tail pointer DEC EDX // set it to last byte before trailing zero SUB ECX, EAX // get length in ECX in 1 CPU cycle SHR ECX, 1 // get length \ 2 in 1 CPU cycle; that's the beauty of power-of-two division
.WHILE ECX > 0 MOV BL, [EDX] // no need to XOR; just overwrite BL and BH contents MOV BH, [EAX] // DynAsm deduces data size from destination register sizes MOV [EDX], BH // ditto, source register sizes MOV [EAX], BL INC EAX // propagate pointers DEC EDX DEC ECX // decrement counter .WEND // point to start of string again MOV EAX, s // MOV = 1 CPU cycle, PUSH + POP = 2 CPU cycles POP EBX // by Windows convention ESI, EDI, EBX must be restored if modified LEAVE // = POP EBP RET
END DYNASM </lang>
Forth
Method 1
<lang forth>: exchange ( a1 a2 -- )
2dup c@ swap c@ rot c! swap c! ;
- reverse ( c-addr u -- )
1- bounds begin 2dup > while 2dup exchange -1 /string repeat 2drop ;
s" testing" 2dup reverse type \ gnitset</lang>
Method 2 Using the stack
<lang forth>\ reverse a string using the data stack for temporary storage
- mystring ( -- caddr len) S" ABCDEFGHIJKLMNOPQRSTUVWXYZ987654321" ;
- 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 ;</lang>
Forth Console Output
mystring type ABCDEFGHIJKLMNOPQRSTUVWXYZ987654321 ok mystring 2dup reverse type 123456789ZYXWVUTSRQPONMLKJIHGFEDCBA ok
Using the Forth-2012 Xchars wordset to handle multi-byte characters
Characters accessed with C@ C! are usually bytes and can therefore only represent characters in 8-bit encodings (e.g., Latin-1). Forth-2012 added the Xchars wordset for dealing with multi-byte encodings such as UTF-8; actually these words are not needed much, because the magic of UTF-8 means that most byte-oriented code works as intended, but the present task is one of the few examples where that is not good enough.
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.
<lang forth>: xreverse {: c-addr u -- c-addr2 u :}
u allocate throw u + c-addr swap over u + >r begin ( from to r:end)
over r@ u< while over r@ over - x-size dup >r - 2dup r@ cmove swap r> + swap repeat
r> drop nip u ;
\ example use s" ώщыē" xreverse type \ outputs "ēыщώ"</lang>
Fortran
<lang fortran>PROGRAM Example
CHARACTER(80) :: str = "This is a string" CHARACTER :: temp INTEGER :: i, length
WRITE (*,*) str length = LEN_TRIM(str) ! Ignores trailing blanks. Use LEN(str) to reverse those as well DO i = 1, length/2 temp = str(i:i) str(i:i) = str(length+1-i:length+1-i) str(length+1-i:length+1-i) = temp END DO WRITE(*,*) str
END PROGRAM Example</lang>
- Output:
This is a string gnirts a si sihT
Another implementation that uses a recursive not-in-place algorithm: <lang fortran>program reverse_string
implicit none character (*), parameter :: string = 'no devil lived on'
write (*, '(a)') string write (*, '(a)') reverse (string)
contains
recursive function reverse (string) result (res)
implicit none character (*), intent (in) :: string character (len (string)) :: res
if (len (string) == 0) then res = else res = string (len (string) :) // reverse (string (: len (string) - 1)) end if
end function reverse
end program reverse_string</lang>
- Output:
no devil lived on no devil lived on
Another shorter implementation (adapted version from stackoverflow question 10605574 how-to-reverse-a-chain-of-character-fortran-90): <lang fortran> program reverse_string
implicit none character (80) :: cadena integer :: k, n ! cadena = "abcdefgh" n = len_trim (cadena) ! write (*,*) cadena forall (k=1:n) cadena (k:k) = cadena (n-k+1:n-k+1) write (*,*) cadena !
end program reverse_string</lang>
- Output:
abcdefgh hgfedcba
FreeBASIC
<lang freebasic>' FB 1.05.0 Win64
Function ReverseString(s As Const String) As String
If s = "" Then Return s Dim length As Integer = Len(s) Dim r As String = Space(length) For i As Integer = 0 To length - 1 r[i] = s[length - 1 - i] Next Return r
End Function
Dim s As String = "asdf" Print "'"; s; "' reversed is '"; ReverseString(s); "'"</lang>
- Output:
'asdf' reversed is 'fdsa'
Frink
The built-in reverse
function reverses a string or the elements of a list.
Frink's built-in reverse[string]
is quite smart and uses a grapheme-based algorithm to handle Unicode correctly. That is, it preserves "user-perceived characters" that may consist of characters, combining accents, high-plane Unicode characters (that is, above U+FFFF,) surrogate pairs, etc. correctly.
Many languages will not work correctly with upper-plane Unicode characters because they are represented as Unicode "surrogate pairs" which are represented as two characters in a UTF-16 stream.
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. <lang frink>println[reverse["abcdef"]]</lang>
Futhark
Futhark has no real strings beyond a little bit of syntactic sugar, so this is the same as reversing an array.
<lang Futhark> fun main(s: []i32) = s[::-1] </lang>
FutureBasic
<lang futurebasic> include "ConsoleWindow"
dim as Str31 str dim as long i
str = "123456789abcdefghijk"
print str print
for i = str[0] to 1 step -1 print mid$( str, i, 1 ); next i </lang>
Output:
123456789abcdefghijk kjihgfedcba987654321
Gambas
Click this link to run this code <lang gambas>Public Sub Main() Dim sString As String = "asdf" Dim sOutput As String Dim siCount As Short
For siCount = Len(sString) DownTo 1
sOutput &= Mid(sString, siCount, 1)
Next
Print sOutput
End</lang> Output:
fdsa
GAP
<lang gap>Reversed("abcdef");
- "fedcba"</lang>
Gema
Reverse each line in the input stream. Using built in function: <lang gema>\L=@reverse{$1}</lang> Not using built in function (recursively apply substring to same rule): <lang gema>\L<U1>=@{$2}$1</lang>
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.
<lang genie>[indent=4] /*
Reverse a string, in Genie valac reverse.gs
- /
init
utf8:string = "asdf" combining:string = "asdf̅"
print utf8 print utf8.reverse()
print combining print combining.reverse()</lang>
- Output:
prompt$ valac reverse.gs prompt$ ./reverse asdf fdsa as?df? ?fd?sa
GFA Basic
<lang> PRINT @reverse$("asdf") ' FUNCTION reverse$(string$)
LOCAL result$,i% result$="" FOR i%=1 TO LEN(string$) result$=MID$(string$,i%,1)+result$ NEXT i% RETURN result$
ENDFUNC </lang>
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. <lang go>package main
import (
"fmt" "unicode" "unicode/utf8"
)
// no encoding func reverseBytes(s string) string {
r := make([]byte, len(s)) for i := 0; i < len(s); i++ { r[i] = s[len(s)-1-i] } return string(r)
}
// reverseCodePoints interprets its argument as UTF-8 and ignores bytes // that do not form valid UTF-8. return value is UTF-8. func reverseCodePoints(s string) string {
r := make([]rune, len(s)) start := len(s) for _, c := range s { // quietly skip invalid UTF-8 if c != utf8.RuneError { start-- r[start] = c } } return string(r[start:])
}
// reversePreservingCombiningCharacters interprets its argument as UTF-8 // and ignores bytes that do not form valid UTF-8. return value is UTF-8. func reversePreservingCombiningCharacters(s string) string {
if s == "" { return "" } p := []rune(s) r := make([]rune, len(p)) start := len(r) for i := 0; i < len(p); { // quietly skip invalid UTF-8 if p[i] == utf8.RuneError { i++ continue } j := i + 1 for j < len(p) && (unicode.Is(unicode.Mn, p[j]) || unicode.Is(unicode.Me, p[j]) || unicode.Is(unicode.Mc, p[j])) { j++ } for k := j - 1; k >= i; k-- { start-- r[start] = p[k] } i = j } return (string(r[start:]))
}
func main() {
test("asdf") test("as⃝df̅")
}
func test(s string) {
fmt.Println("\noriginal: ", []byte(s), s) r := reverseBytes(s) fmt.Println("reversed bytes:", []byte(r), r) fmt.Println("original code points:", []rune(s), s) r = reverseCodePoints(s) fmt.Println("reversed code points:", []rune(r), r) r = reversePreservingCombiningCharacters(s) fmt.Println("combining characters:", []rune(r), r)
}</lang>
- Output:
original: [97 115 100 102] asdf reversed bytes: [102 100 115 97] fdsa original code points: [97 115 100 102] asdf reversed code points: [102 100 115 97] fdsa combining characters: [102 100 115 97] fdsa original: [97 115 226 131 157 100 102 204 133] as⃝df̅ reversed bytes: [133 204 102 100 157 131 226 115 97] ��fd���sa original code points: [97 115 8413 100 102 773] as⃝df̅ reversed code points: [773 102 100 8413 115 97] ̅fd⃝sa combining characters: [102 773 100 115 8413 97] f̅ds⃝a
Groovy
Solution:
<lang groovy>println "Able was I, 'ere I saw Elba.".reverse()</lang>
- Output:
.ablE was I ere' ,I saw elbA
Extra Credit:
<lang groovy>def string = "as⃝df̅"
List combiningBlocks = [
Character.UnicodeBlock.COMBINING_DIACRITICAL_MARKS, Character.UnicodeBlock.COMBINING_DIACRITICAL_MARKS_SUPPLEMENT, Character.UnicodeBlock.COMBINING_HALF_MARKS, Character.UnicodeBlock.COMBINING_MARKS_FOR_SYMBOLS
] List chars = string as List chars[1..-1].eachWithIndex { ch, i ->
if (Character.UnicodeBlock.of((char)ch) in combiningBlocks) { chars[i..(i+1)] = chars[(i+1)..i] }
} println chars.reverse().join()</lang>
- Output:
f̅ds⃝a
Harbour
<lang visualfoxpro>FUNCTION Reverse( sIn )
LOCAL cOut := "", i
FOR i := Len( sIn ) TO 1 STEP -1 cOut += Substr( sIn, i, 1 ) NEXT
RETURN cOut</lang>
Haskell
<lang haskell>reverse = foldl (flip (:)) []</lang> This function as defined in the Haskell Prelude.
Though variants using a helper function with an additional accumulator argument are more efficient, and are now used by default in GHC.List unless the USE_REPORT_PRELUDE key is set.
Perhaps, for example: <lang haskell>accumulatingReverse :: [a] -> [a] accumulatingReverse lst =
let rev xs a = foldl (flip (:)) a xs in rev lst []</lang>
Supporting combining characters
<lang haskell>import Data.Char (isMark)
import Data.List (groupBy)
myReverse = concat . reverse . groupBy (const isMark)</lang>
groupBy (const isMark)
is an unusual way of splitting a string into its combined characters
HicEst
<lang hicest>CHARACTER string = "Hello World", tmp
L = LEN( string ) DO i = 1, L/2
tmp = string(i) string(i) = string(L-i+1) string(L-i+1) = tmp
ENDDO
WRITE(Messagebox, Name) string </lang>
Icon and Unicon
<lang Icon>procedure main(arglist) s := \arglist[1] | "asdf" write(s," <-> ", reverse(s)) # reverse is built-in end</lang>
Io
<lang io>"asdf" reverse</lang>
J
Reverse (|.) reverses a list of items (of any shape or type). <lang j> |.'asdf' fdsa</lang> Extra credit: First, a function to determine whether a Unicode character is a combining character: <lang j> ranges=.16b02ff 16b036f, 16b1dbf 16b1dff, 16b20cf 16b20ff, 16bfe1f 16bfe2f
iscombining=. 2 | ranges&I.</lang>
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. <lang j> split=. (<;.1~ -.@iscombining) :. ;</lang>
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. <lang j> |.&.split&.(3 u: 7&u:) 'as⃝df̅' f̅ds⃝a</lang>
Java
<lang java>public static String reverseString(String s) {
return new StringBuffer(s).reverse().toString();
}</lang>
<lang java5>public static String reverseString(String s) {
return new StringBuilder(s).reverse().toString();
}</lang>
JavaScript
ES5
<lang javascript>//using chained methods function reverseStr(s) {
return s.split().reverse().join();
}
//fast method using for loop function reverseStr(s) {
for (var i = s.length - 1, o = ; i >= 0; o += s[i--]) { } return o;
}
//fast method using while loop (faster with long strings in some browsers when compared with for loop) function reverseStr(s) {
var i = s.length, o = ; while (i--) o += s[i]; return o;
}</lang>
ES6
<lang JavaScript>(() => {
// .reduceRight() can be useful when reversals // are composed with some other process
let reverse1 = s => Array.from(s) .reduceRight((a, x) => a + (x !== ' ' ? x : ' <- '), ),
// but ( join . reverse . split ) is faster for // simple string reversals in isolation
reverse2 = s => s.split().reverse().join();
return [reverse1, reverse2] .map(f => f("Some string to be reversed"));
})();</lang>
- Output:
<lang JavaScript>["desrever <- eb <- ot <- gnirts <- emoS", "desrever eb ot gnirts emoS"]</lang>
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. <lang jq>def reverse_string: explode | reverse | implode;</lang> Examples:
"nöel" | reverse_string # => "leön"
"as⃝df̅" | reverse_string # => "̅fd⃝sa"
Jsish
ECMAScript has no builtin string reversal, so split the characters into an array, reverse the array and join it back together.
Jsi only supports UTF-8 literals so far (in release 2.8), character by character manipulation routines of multibyte UTF-8 data will not be correct. No extra credit, yet. <lang javascript>var str = "Never odd or even"; puts(str); puts(str.split().reverse().join());</lang>
- Output:
Never odd or even neve ro ddo reveN
Julia
<lang julia>julia> reverse("hey")
"yeh"</lang>
The reverse
function reverses codepoints (because this is the right behavior for the main application of string reversal: reversed string processing by external C libraries). However, 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:
<lang julia>julia> join(reverse(collect(graphemes("as⃝df̅"))))
"f̅ds⃝a"</lang>
K
Monadic reverse (| ) verb reverses a string or list of any shape <lang K>
|"asdf"
"fdsa"
| 23 4 5 1
1 5 4 23 </lang>
Kotlin
<lang kotlin>fun main(args: Array<String>) {
println("asdf".reversed())
}</lang>
L++
<lang lisp>(include "string" "algorithm") (main
(decl std::string s) (std::getline std::cin s) (std::reverse (s.begin) (s.end)) (prn s))</lang>
LabVIEW
This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.
Lambdatalk
<lang Scheme> {S.reverse hello brave new world} -> world new brave hello </lang>
Lang5
<lang lang5>: flip "" split reverse "" join ; "qwer asdf" flip .</lang>
langur
This accounts for code points, but not for graphemes. <lang langur>writeln cp2s reverse s2cp q(don't you know)</lang>
- Output:
wonk uoy t'nod
Lasso
<lang Lasso>local(input) = 'asdf'
- input->reverse</lang>
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. <lang Lasso>local(input = 'asdf', output = array) with i in #input->values do #output->insertFirst(#i)
- output->join</lang>
LC3 Assembly
A string is stored as a zero-terminated array of character codes. To reverse it, we first scan forwards until we find the end; we then move backwards again, copying each code into a block of memory we have reserved for the purpose; and finally, when we have got back to the beginning, we append a terminal zero to the new string we have created. We can then call PUTS to print it. <lang lc3asm> .ORIG 0x3000
LEA R1,STRING LEA R2,GNIRTS LD R3,MINUS1 NOT R5,R1 ADD R5,R5,1
SCAN LDR R4,R1,0
BRZ COPY ADD R1,R1,1 BRNZP SCAN
COPY ADD R1,R1,R3
ADD R4,R1,R5 BRN COPIED LDR R4,R1,0 STR R4,R2,0 ADD R2,R2,1 BRNZP COPY
COPIED AND R4,R4,0
STR R4,R2,0
LEA R0,GNIRTS PUTS
HALT
MINUS1 .FILL 0xFFFF
STRING .STRINGZ "If thou beest he -- but O how fall'n! how chang'd" GNIRTS .BLKW 128
.END</lang>
- Output:
d'gnahc woh !n'llaf woh O tub -- eh tseeb uoht fI
LFE
Ordinary string: <lang lisp> > (lists:reverse "asdf") "fdsa" </lang>
Create a UTF-8 encoded string: <lang lisp> > (set encoded (binary ("åäö ð" utf8)))
- B(195 165 195 164 195 182 32 195 176)
</lang>
Display it, to be sure: <lang lisp> > (io:format "~tp~n" (list encoded)) <<"åäö ð"/utf8>> </lang>
Reverse it: <lang lisp> > (lists:reverse (unicode:characters_to_list encoded)) "ð öäå" </lang>
Liberty BASIC
<lang lb>input$ ="abcdefgABCDEFG012345" print input$ print ReversedStr$( input$)
end
function ReversedStr$(in$)
for i =len(in$) to 1 step -1 ReversedStr$ =ReversedStr$ +mid$( in$, i, 1) next i
end function</lang>
Lingo
Lingo strings are always UTF-8 encoded and string operations are based on Unicode code points, so the "extra credit" is built-in: <lang lingo>on reverse (str)
res = "" repeat with i = str.length down to 1 put str.char[i] after res end repeat return res
end</lang> To reverse a string byte-wise, the ByteArray data type has to be used: <lang lingo>on reverseBytes (str)
ba = byteArray(str) res = byteArray() repeat with i = ba.length down to 1 res[res.length+1] = ba[i] end repeat return res
end</lang>
LiveCode
<lang livecode>function reverseString S
repeat with i = length(S) down to 1 put char i of S after R end repeat return R
end reverseString</lang>
LLVM
<lang llvm>; This is not strictly LLVM, as it uses the C library function "printf".
- LLVM does not provide a way to print values, so the alternative would be
- to just load the string into memory, and that would be boring.
- Additional comments have been inserted, as well as changes made from the output produced by clang such as putting more meaningful labels for the jumps
$"main.printf" = comdat any
@main.str = private unnamed_addr constant [12 x i8] c"Hello world\00", align 1 @"main.printf" = linkonce_odr unnamed_addr constant [4 x i8] c"%s\0A\00", comdat, align 1
define void @reverse(i64, i8*) {
%3 = alloca i8*, align 8 ; allocate str (local) %4 = alloca i64, align 8 ; allocate len (local) %5 = alloca i64, align 8 ; allocate i %6 = alloca i64, align 8 ; allocate j %7 = alloca i8, align 1 ; allocate t store i8* %1, i8** %3, align 8 ; set str (local) to the parameter str store i64 %0, i64* %4, align 8 ; set len (local) to the paremeter len store i64 0, i64* %5, align 8 ; i = 0 %8 = load i64, i64* %4, align 8 ; load len %9 = sub i64 %8, 1 ; decrement len store i64 %9, i64* %6, align 8 ; j = br label %loop
loop:
%10 = load i64, i64* %5, align 8 ; load i %11 = load i64, i64* %6, align 8 ; load j %12 = icmp ult i64 %10, %11 ; i < j br i1 %12, label %loop_body, label %exit
loop_body:
%13 = load i8*, i8** %3, align 8 ; load str %14 = load i64, i64* %5, align 8 ; load i %15 = getelementptr inbounds i8, i8* %13, i64 %14 ; address of str[i] %16 = load i8, i8* %15, align 1 ; load str[i] store i8 %16, i8* %7, align 1 ; t = str[i] %17 = load i64, i64* %6, align 8 ; load j %18 = getelementptr inbounds i8, i8* %13, i64 %17 ; address of str[j] %19 = load i8, i8* %18, align 1 ; load str[j] %20 = getelementptr inbounds i8, i8* %13, i64 %14 ; address of str[i] store i8 %19, i8* %20, align 1 ; str[i] = str[j] %21 = load i8, i8* %7, align 1 ; load t %22 = getelementptr inbounds i8, i8* %13, i64 %17 ; address of str[j] store i8 %21, i8* %22, align 1 ; str[j] = t
- -- loop increment
%23 = load i64, i64* %5, align 8 ; load i %24 = add i64 %23, 1 ; increment i store i64 %24, i64* %5, align 8 ; store i %25 = load i64, i64* %6, align 8 ; load j %26 = add i64 %25, -1 ; decrement j store i64 %26, i64* %6, align 8 ; store j br label %loop
exit:
ret void
}
define i32 @main() {
- -- char str[]
%1 = alloca [12 x i8], align 1
- -- memcpy(str, "Hello world")
%2 = bitcast [12 x i8]* %1 to i8* call void @llvm.memcpy.p0i8.p0i8.i64(i8* %2, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @main.str, i32 0, i32 0), i64 12, i32 1, i1 false)
- -- printf("%s\n", str)
%3 = getelementptr inbounds [12 x i8], [12 x i8]* %1, i32 0, i32 0 %4 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @"main.printf", i32 0, i32 0), i8* %3)
- -- %7 = strlen(str)
%5 = getelementptr inbounds [12 x i8], [12 x i8]* %1, i32 0, i32 0 %6 = call i64 @strlen(i8* %5)
- -- reverse(%6, str)
call void @reverse(i64 %6, i8* %5)
- -- printf("%s\n", str)
%7 = getelementptr inbounds [12 x i8], [12 x i8]* %1, i32 0, i32 0 %8 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @"main.printf", i32 0, i32 0), i8* %7)
- -- end of main
ret i32 0
}
- --- The declaration for the external C printf function.
declare i32 @printf(i8*, ...)
- Function Attrs
- argmemonly nounwind
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32, i1)
declare i64 @strlen(i8*)</lang>
- Output:
Hello world dlrow olleH
Logo
REVERSE works on both words and lists. <lang logo>print reverse "cat ; tac</lang>
Lua
Built-in string.reverse(s) or s:reverse(). <lang lua>theString = theString:reverse()</lang>
M2000 Interpreter
Using Custom Function
Version 2, using insert to string (with no copies of strings) <lang M2000 Interpreter> Module ReverseString {
a$="as⃝df̅" Print Len(a$), len.disp(a$) Let i=1, j=Len(a$) z$=String$(" ",j) j++ do { k$=mid$(a$, i, 1) if i<len(a$) then { while len.disp(k$+mid$(a$, i+1,1)) =len.disp(k$) { k$+=mid$(a$, i+1,1) i++ if i>len(a$) then exit j-- } j-- insert j, len(k$) Z$=K$ } else j-- :Insert j,1 z$=k$ if i>=len(a$) then exit i++ } Always Print len(z$), len.disp(z$) Print z$="f̅ds⃝a" Print z$
} ReverseString </lang>
using StrRev$()
this function (new to 9.5 version) use StrReverse from Vb6 <lang M2000 Interpreter> a$="as⃝df̅" b$=strrev$(a$) clipboard b$ Print b$="̅fd⃝sa" </lang>
M4
<lang m4>define(`invert',`ifelse(len(`$1'),0,,`invert(substr(`$1',1))'`'substr(`$1',0,1))')</lang>
Maclisp
<lang lisp>(readlist (reverse (explode "my-string")))</lang> Output:
"gnirts-ym"
Maple
<lang Maple>> StringTools:-Reverse( "foo" );
"oof"</lang>
Mathematica/Wolfram Language
<lang mathematica>StringReverse["asdf"]</lang>
MATLAB
A built-in function, "fliplr(string)" handles reversing a string of ASCII characters. Unicode is a whole other beast, if you need this functionality test to see if "fliplr()" properly handles the unicode characters you use. If it doesn't then you will need to code a function that is specific to your application.
Sample Usage: <lang MATLAB>>> fliplr(['She told me that she spoke English and I said great. '... 'Grabbed her hand out the club and I said lets 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</lang>
Maxima
<lang maxima>sreverse("abcdef"); /* "fedcba" */
sreverse("rats live on no evil star"); /* not a bug :o) */</lang>
MAXScript
<lang maxscript>fn reverseString s = (
local reversed = "" for i in s.count to 1 by -1 do reversed += s[i] reversed
)</lang>
min
<lang min>("" split reverse "" join) :reverse-str</lang>
MiniScript
<lang MiniScript>str = "This is a string" print "Forward: " + str newStr = "" for i in range(str.len-1, 0)
newStr = newStr + str[i]
end for print "Reversed: " + newStr</lang>
- Output:
Forward: This is a string Reversed: gnirts a si sihT
MIPS Assembly
<lang mips>
- First, it gets the length of the original string
- Then, it allocates memory from the copy
- Then it copies the pointer to the original string, and adds the strlen
- subtract 1, then that new pointer is at the last char.
- while(strlen)
- copy char
- decrement strlen
- decrement source pointer
- increment target pointer
.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 "Nice string you got there!\n" </lang>
Mirah
<lang mirah>def reverse(s:string)
StringBuilder.new(s).reverse
end
puts reverse('reversed')</lang>
Modula-2
<lang modula2>MODULE ReverseStr; FROM FormatString IMPORT FormatString; FROM Terminal IMPORT Write,WriteString,WriteLn,ReadChar;
PROCEDURE WriteInt(n : INTEGER); VAR buf : ARRAY[0..15] OF CHAR; BEGIN
FormatString("%i", buf, n); WriteString(buf)
END WriteInt;
PROCEDURE ReverseStr(in : ARRAY OF CHAR; VAR out : ARRAY OF CHAR); VAR ip,op : INTEGER; BEGIN
ip := 0; op := 0; WHILE in[ip] # 0C DO INC(ip) END; DEC(ip); WHILE ip>=0 DO out[op] := in[ip]; INC(op); DEC(ip) END
END ReverseStr;
TYPE A = ARRAY[0..63] OF CHAR; VAR is,os : A; BEGIN
is := "Hello World"; ReverseStr(is, os);
WriteString(is); WriteLn; WriteString(os); WriteLn;
ReadChar
END ReverseStr.</lang>
Modula-3
<lang modula3>MODULE Reverse EXPORTS Main;
IMPORT IO, Text;
PROCEDURE String(item: TEXT): TEXT =
VAR result: TEXT := ""; BEGIN FOR i := Text.Length(item) - 1 TO 0 BY - 1 DO result := Text.Cat(result, Text.FromChar(Text.GetChar(item, i))); END; RETURN result; END String;
BEGIN
IO.Put(String("Foobarbaz") & "\n");
END Reverse.</lang>
- Output:
zabrabooF
MUMPS
<lang MUMPS>REVERSE
;Take in a string and reverse it using the built in function $REVERSE NEW S READ:30 "Enter a string: ",S WRITE !,$REVERSE(S) QUIT</lang>
- Output:
USER>D REVERSE^ROSETTA Enter a string: Hello, World! !dlroW ,olleH
Nanoquery
<lang Nanoquery>def reverse(string)
l = ""
for char in list(str(string)).reverse() l += char end
return l
end</lang>
Neko
No extra credit for UTF in this example. <lang actionscript>/* Reverse a string, in Neko */
var reverse = function(s) {
var len = $ssize(s) if len < 2 return s
var reverse = $smake(len) var pos = 0 while len > 0 $sset(reverse, pos ++= 1, $sget(s, len -= 1)) return reverse
}
var str = "never odd or even" $print(str, "\n") $print(reverse(str), "\n\n")
str = "abcdefghijklmnopqrstuvwxyz" $print(str, "\n") $print(reverse(str), "\n\n")
$print("single test\n") str = "a" $print(str, "\n") $print(reverse(str), "\n\n")
$print("empty test\n")
str = ""
$print(str, "\n")
$print(reverse(str), "\n")</lang>
- Output:
prompt$ nekoc reverse.neko prompt$ neko reverse.n never odd or even neve ro ddo reven abcdefghijklmnopqrstuvwxyz zyxwvutsrqponmlkjihgfedcba single test a a empty test
Nemerle
Supporting Combining Characters
Compile with:
ncc -reference:System.Windows.Forms reverse.n
<lang Nemerle>using System; using System.Globalization; using System.Windows.Forms; using System.Console; using Nemerle.Utility.NString;
module StrReverse {
UReverse(text : string) : string { mutable output = []; def elements = StringInfo.GetTextElementEnumerator(text); while (elements.MoveNext()) output ::= elements.GetTextElement().ToString(); Concat("", output.Reverse()); } Main() : void { def test = "as⃝df̅"; MessageBox.Show($"$test --> $(UReverse(test))"); //for whatever reason my console didn't display Unicode properly, but a MessageBox worked }
}</lang>
Basic Reverse
Doesn't require the System.Globalization namespace, probably a little less overhead. <lang Nemerle>Reverse(text : string) : string {
mutable output = []; foreach (c in text.ToCharArray()) output ::= c.ToString(); Concat("", output)
}</lang>
NetRexx
<lang NetRexx>/* NetRexx */
options replace format comments java crossref savelog symbols nobinary
reverseThis = 'asdf' sihTesrever = reverseThis.reverse
say reverseThis say sihTesrever
return</lang>
- Output:
asdf fdsa
NewLISP
<lang NewLISP>(reverse "!dlroW olleH")</lang>
Nial
<lang nial>reverse 'asdf' =fdsa</lang>
Nim
<lang nim>import unicode
proc reverse(s: var string) =
for i in 0 .. s.high div 2: swap(s[i], s[s.high - i])
proc reversed(s: string): string =
result = newString(s.len) for i,c in s: result[s.high - i] = c
proc uniReversed(s: string): string =
result = newStringOfCap(s.len) var tmp: seq[Rune] = @[] for r in runes(s): tmp.add(r) for i in countdown(tmp.high, 0): result.add(toUtf8(tmp[i]))
proc isComb(r: Rune): bool =
(r >=% Rune(0x300) and r <=% Rune(0x36f)) or (r >=% Rune(0x1dc0) and r <=% Rune(0x1dff)) or (r >=% Rune(0x20d0) and r <=% Rune(0x20ff)) or (r >=% Rune(0xfe20) and r <=% Rune(0xfe2f))
proc uniReversedPreserving(s: string): string =
result = newStringOfCap(s.len) var tmp: seq[Rune] = @[] for r in runes(s): if isComb(r): tmp.insert(r, tmp.high) else: tmp.add(r) for i in countdown(tmp.high, 0): result.add(toUtf8(tmp[i]))
for str in ["Reverse This!", "as⃝df̅"]:
echo "Original string: ", str echo "Reversed: ", reversed(str) echo "UniReversed: ", uniReversed(str) echo "UniReversedPreserving: ", uniReversedPreserving(str)</lang>
- Output:
Original string: Reverse This! Reversed: !sihT esreveR UniReversed: !sihT esreveR UniReversedPreserving: !sihT esreveR Original string: as⃝df̅ Reversed: Ìfdâsa UniReversed: ‾fd⃝sa UniReversedPreserving: f̅ds⃝a
Since Nim 0.11.0, the unicode module provides a reversed proc... Hence:
<lang nim>import unicode
doAssert "foobar".reversed == "raboof" doAssert "先秦兩漢".reversed == "漢兩秦先"</lang>
NS-HUBASIC
<lang NS-HUBASIC>10 STRING$="THIS TEXT IS REVERSED." 20 REVERSED$="" 30 FOR I=1 TO LEN(STRING$) 40 REVERSED$=MID$(STRING$,I,1)+REVERSED$ 50 NEXT 60 PRINT REVERSED$</lang>
Oberon
Tested with OBNC. <lang Oberon>MODULE reverse;
IMPORT Out, Strings; VAR s: ARRAY 12 + 1 OF CHAR; PROCEDURE Swap(VAR c, d: CHAR); VAR oldC: CHAR; BEGIN oldC := c; c := d; d := oldC END Swap;
PROCEDURE Reverse(VAR s: ARRAY OF CHAR); VAR len, i: INTEGER; BEGIN len := Strings.Length(s); FOR i := 0 TO len DIV 2 DO Swap(s[i], s[len - 1 - i]) END END Reverse;
BEGIN
s := "hello, world"; Reverse(s); Out.String(s); Out.Ln
END reverse.</lang>
Objeck
<lang objeck> result := "asdf"->Reverse(); </lang>
Objective-C
This extends the NSString
object adding a reverseString
class method.
<lang objc>#import <Foundation/Foundation.h>
@interface NSString (Extended) -(NSString *)reverseString; @end
@implementation NSString (Extended) -(NSString *) reverseString {
NSUInteger len = [self length]; NSMutableString *rtr=[NSMutableString stringWithCapacity:len]; // unichar buf[1]; while (len > (NSUInteger)0) { unichar uch = [self characterAtIndex:--len]; [rtr appendString:[NSString stringWithCharacters:&uch length:1]]; } return rtr;
} @end</lang> Usage example: <lang objc>int main() {
@autoreleasepool { NSString *test = [@"!A string to be reverted!" reverseString]; NSLog(@"%@", test); } return 0;
}</lang>
Supporting combining characters
Extra credit <lang objc>#import <Foundation/Foundation.h>
@interface NSString (Extended) -(NSString *)reverseString; @end
@implementation NSString (Extended) -(NSString *)reverseString { NSInteger l = [self length] - 1; NSMutableString *ostr = [NSMutableString stringWithCapacity:[self length]]; while (l >= 0) { NSRange range = [self rangeOfComposedCharacterSequenceAtIndex:l]; [ostr appendString:[self substringWithRange:range]]; l -= range.length; } return ostr; } @end</lang> Usage example: <lang objc>int main() {
@autoreleasepool { NSString *test = [@"as⃝df̅" reverseString]; NSLog(@"%@", test); } return 0;
}</lang>
OCaml
Since OCaml 4.02 we can use the handy String.init function.
Here a version that returns a new allocated string (preserving the original one):
<lang ocaml>let string_rev s =
let len = String.length s in String.init len (fun i -> s.[len - 1 - i])
let () =
print_endline (string_rev "Hello world!")</lang>
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:
<lang ocaml>let rev_bytes bs =
let last = Bytes.length bs - 1 in for i = 0 to last / 2 do let j = last - i in let c = Bytes.get bs i in Bytes.set bs i (Bytes.get bs j); Bytes.set bs j c; done
let () =
let s = Bytes.of_string "Hello World" in rev_bytes s; print_bytes s; print_newline ();
- </lang>
Here is a 100% functionnal string reversing function: <lang ocaml>let rec revs_aux strin list index =
if List.length list = String.length strin then String.concat "" list else revs_aux strin ((String.sub strin index 1)::list) (index+1)
let revs s = revs_aux s [] 0
let () =
print_endline (revs "Hello World!")</lang>
will return "!dlroW olleH"
Octave
<lang octave>s = "a string"; rev = s(length(s):-1:1)</lang>
Oforth
<lang Oforth>reverse</lang>
Ol
<lang scheme> (define (rev s)
(runes->string (reverse (string->runes s))))
- testing
(print (rev "Hello, λ!"))
- ==> !λ ,olleH
</lang>
OOC
<lang ooc> main: func {
"asdf" reverse() println() // prints "fdsa"
} </lang>
OpenEdge/Progress
<lang OpenEdge/Progress>FUNCTION reverseString RETURNS CHARACTER (
INPUT i_c AS CHARACTER
):
DEFINE VARIABLE cresult AS CHARACTER NO-UNDO. DEFINE VARIABLE ii AS INTEGER NO-UNDO.
DO ii = LENGTH( i_c ) TO 1 BY -1: cresult = cresult + SUBSTRING( i_c, ii, 1 ). END. RETURN cresult.
END FUNCTION.
MESSAGE reverseString( "asdf" ) VIEW-AS ALERT-BOX.</lang>
OxygenBasic
<lang oxygenbasic>
'8 BIT CHARACTERS
string s="qwertyuiop" sys a,b,i,j,le=len s ' for i=1 to le
j=le-i+1 if j<=i then exit for a=asc s,i b=asc s,j mid s,j,chr a mid s,i,chr b
next '
print s
'16 BIT CHARACTERS
wstring s="qwertyuiop" sys a,b,i,j,le=len s ' for i=1 to le
j=le-i+1 if j<=i then exit for a=unic s,i b=unic s,j mid s,j,wchr a mid s,i,wchr b
next ' print s </lang>
OxygenBasic x86 Assembler
32 bit code, 8-bit characters: <lang oxygenbasic>
string s="qwertyuiop" sys p=strptr s, le=len s mov esi,p mov edi,esi add edi,le dec edi (
cmp esi,edi jge exit mov al,[esi] mov ah,[edi] mov [esi],ah mov [edi],al inc esi dec edi repeat
)
print s </lang>
Oz
Strings are lists. A function "Reverse" defined on lists is part of the implementation. <lang oz>{System.showInfo {Reverse "!dlroW olleH"}}</lang> An efficient (tail-recursive) implementation could look like this: <lang oz>local
fun {DoReverse Xs Ys} case Xs of nil then Ys [] X|Xr then {DoReverse Xr X|Ys} end end
in
fun {Reverse Xs} {DoReverse Xs nil} end
end</lang> Oz uses a single-byte encoding by default. If you decide to use a multi-byte encoding, Reverse will not work correctly.
PARI/GP
Version #1.
<lang parigp>reverse(s)=concat(Vecrev(s))</lang>
Version #2.
<lang parigp> \\ Return reversed string str. \\ 3/3/2016 aev sreverse(str)={return(Strchr(Vecrev(Vecsmall(str))))}
{ \\ TEST1 print(" *** Testing sreverse from Version #2:"); print(sreverse("ABCDEF")); my(s,sr,n=10000000); s="ABCDEFGHIJKL"; for(i=1,n, sr=sreverse(s)); } </lang>
- Output:
*** Testing sreverse from Version #2: FEDCBA (17:28) gp > ## *** last result computed in 8,642 ms.
<lang parigp> \\ Version #1 upgraded to complete function. Practically the same. reverse(str)={return(concat(Vecrev(str)))}
{ \\ TEST2 print(" *** Testing reverse from Version #1:"); print(reverse("ABCDEF")); my(s,sr,n=10000000); s="ABCDEFGHIJKL"; for(i=1,n, sr=reverse(s)); } </lang>
- Output:
*** Testing reverse from Version #1: FEDCBA (17:31) gp > ## *** last result computed in 11,814 ms.
Pascal
The following examples handle correctly only single-byte encodings.
Standard Pascal
The following only works on implementations which implement Level 1 of standard Pascal (many popular compilers don't).
Standard Pascal doesn't have a separate string type, but uses arrays of char for strings. Note that Standard Pascal doesn't allow a return type of char array, therefore the destination array is passed through a var parameter (which is more efficient anyway). <lang pascal>{ the result array must be at least as large as the original array } procedure reverse(s: array[min .. max: integer] of char, var result: array[min1 .. max1: integer] of char);
var i, len: integer; begin len := max-min+1; for i := 0 to len-1 do result[min1 + len-1 - i] := s[min + i] end;</lang>
<lang pascal>{Copy and paste it in your program} function revstr(my_s:string):string;
var out_s:string; ls,i:integer; begin ls:=length(my_s); for i:=1 to ls do out_s:=out_s+my_s[ls-i+1]; revstr:=out_s; end;</lang>
Extended Pascal, Turbo Pascal, Delphi and compatible compilers
<lang pascal>function reverse(s:string):string; var i:integer; var tmp:char; begin
for i:=1 to length(s) div 2 do begin tmp:=s[i]; s[i]:=s[length(s)+1-i]; s[length(s)+1-i]:=tmp; reverse:=s; end;
end;</lang> alternative as procedure which changes the original <lang pascal>procedure revString(var s:string); var
i,j:integer; tmp:char;
begin
i := 1; j := length(s); while i<j do begin tmp:=s[i]; s[i]:=s[j]; s[j]:=tmp; inc(i); dec(j) end;
end;</lang>
Peloton
Padded out, variable length Chinese dialect <lang sgml><# 显示 指定 变量 反转顺序 字串>集装箱|猫坐在垫子</#></lang>
This assigns the reverse of 'the cat sat on the mat' to the variable 'container' and displays the result which is
子垫在坐猫
which Google Translate renders as
Sub-pad sitting cat
.
The same again but with everything in Korean. <lang sgml><# 보이십 할당하 변물건 열거꾸 문자그>컨테이너|고양이가 매트 위에 앉아</#></lang>
Reversing the Korean makes an untranslatable-by-Google mess of the sentence, viz
아앉 에위 트매 가이양고
.
The short-opcode version in English dialect is <lang sgml><@ SAYLETVARREVLIT>集装箱|猫坐在垫子</@></lang> Peloton works in Unicode.
Perl
<lang perl>use utf8; binmode STDOUT, ":utf8";
- to reverse characters (code points):
print reverse('visor'), "\n";
- to reverse graphemes:
print join("", reverse "José" =~ /\X/g), "\n";
$string = 'ℵΑΩ 駱駝道 🤔 🇸🇧 🇺🇸 🇬🇧 👨👩👧👦🆗🗺'; print join("", reverse $string =~ /\X/g), "\n";</lang>
- Output:
rosiv ésoJ 🗺🆗👨👩👧👦 🇬🇧 🇺🇸 🇸🇧 🤔 道駝駱 ΩΑℵ
Pharo
<lang Pharo>'123' reversed</lang>
Phix
<lang Phix>?reverse("asdf")</lang>
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).
Note that XXXX_redacted#Phix adds some ZERO-WIDTH-JOINER handling to the inner code.
<lang Phix>function unicode_reverse(string utf8)
sequence utf32 = utf8_to_utf32(utf8)
integer ch
-- The assumption is made that <char><comb1><comb2> -- and <char><comb2><comb1> etc would work the same. -- The following loop converts <char><comb1><comb2> -- to <comb1><comb2><char>, as a pre-reverse() step. for i=1 to length(utf32) do ch = utf32[i] if (ch>=0x300 and ch<=0x36f) or (ch>=0x1dc0 and ch<=0x1dff) or (ch>=0x20d0 and ch<=0x20ff) or (ch>=0xfe20 and ch<=0xfe2f) then utf32[i] = utf32[i-1] utf32[i-1] = ch end if end for utf32 = reverse(utf32) utf8 = utf32_to_utf8(utf32) return utf8
end function</lang>
PHP
<lang php>strrev($string);</lang>
If you want Unicode support, you have to use some multibyte function. Sadly, PHP doesn't contain mb_strrev()
. One of functions which support Unicode and is useful in this case is preg_split()
.
<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)));</lang>
PicoLisp
<lang PicoLisp>(pack (flip (chop "äöüÄÖÜß")))</lang>
- Output:
-> "ßÜÖÄüöä"
Pike
For simple ASCII: <lang Pike>reverse("foo");</lang>
- Output:
"oof"
When dealing with Unicode (or any other supported encoding) care must be taken primarily in the output step to serialize the Unicode string into something the sink can handle. IO functions will throw an error if sent raw wide strings.
<lang Pike>#charset utf8 void main() {
string s = "ßÜÖÄüöää ἀρχῇ"; write("%s\n", string_to_utf8( reverse(s) ));
}</lang>
- Output:
ῇχρἀ ääöüÄÖÜß
PL/I
<lang PL/I>s = reverse(s);</lang>
Plain English
<lang plainenglish>To run: Start up. Put "asdf" into a string. Reverse the string. Shut down.</lang>
Plain TeX
Works well if the string has no space (spaces are gobbled).
<lang tex>\def\gobtoA#1\revA{}\def\gobtoB#1\revB{} \def\reverse#1{\reversei{}#1\revA\revB\revB\revB\revB\revB\revB\revB\revB\revA} \def\reversei#1#2#3#4#5#6#7#8#9{\gobtoB#9\revend\revB\reversei{#9#8#7#6#5#4#3#2#1}} \def\revend\revB\reversei#1#2\revA{\gobtoA#1} \reverse{Rosetta} \bye</lang>
Output:
attesoR
Pop11
<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;</lang>
PostScript
The following implementation works on arrays of numerics as well as characters ( string ). <lang PostScript>/reverse{ /str exch def /temp str 0 get def /i 0 def str length 2 idiv{ /temp str i get def str i str str length i sub 1 sub get put str str length i sub 1 sub temp put /i i 1 add def }repeat str pstack }def</lang>
- Output:
<lang PostScript>[1 2 3] reverse % input [3 2 1]
(Hello World) reverse % input (dlroW olleH)</lang>
PowerBASIC
<lang powerbasic>#DIM ALL
- COMPILER PBCC 6
FUNCTION PBMAIN () AS LONG CON.PRINT STRREVERSE$("PowerBASIC") END FUNCTION</lang>
PowerShell
Test string <lang powershell>$s = "asdf"</lang>
Array indexing
Creating a character array from the end to the string's start and join it together into a string again.
<lang powershell>[string]::Join(, $s[$s.Length..0])</lang>
<lang powershell>-join ($s[$s.Length..0])</lang>
<lang powershell>[array]::Reverse($s)</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.
<lang powershell>$s -replace
('(.)' * $s.Length), [string]::Join(, ($s.Length..1 | ForEach-Object { "`$$_" }))</lang>
<lang powershell>$s -replace
('(.)' * $s.Length), -join ($s.Length..1 | ForEach-Object { "`$$_" } )</lang>
<lang PowerShell> [Regex]::Matches('abc','.','RightToLeft').Value -join </lang>
- Output:
cba
Prolog
<lang prolog>reverse("abcd", L), string_to_list(S,L).</lang>
- Output:
L = [100,99,98,97], S = "dcba".
The main workings are hidden inside the reverse/2 predicate, so lets write one to see how it works: <lang prolog>accRev([H|T], A, R) :- accRev(T, [H|A], R). accRev([], A, A).
rev(L,R) :- accRev(L,[],R).</lang>
PureBasic
<lang PureBasic>Debug ReverseString("!dekrow tI")</lang>
Python
Optimized for user input
<lang python>input()[::-1]</lang>
Already known string
<lang python>string[::-1]</lang> or <lang python>.join(reversed(string))</lang>
Python: Unicode reversal
(See this article for more information from which this is improved)
Note: How this looks may be subject to how the tool you are using to view this page can render Unicode. <lang python>import unicodedata
def ureverse(ustring):
'Reverse a string including unicode combining characters' groupedchars = [] uchar = list(ustring) while uchar: if unicodedata.combining(uchar[0]) != 0: groupedchars[-1] += uchar.pop(0) else: groupedchars.append(uchar.pop(0)) # Grouped reversal groupedchars = groupedchars[::-1] return .join(groupedchars)
def say_string(s):
return ' '.join([s, '=', ' | '.join(unicodedata.name(ch, ) for ch in s)])
def say_rev(s):
print(f"Input: {say_string(s)}") print(f"Character reversed: {say_string(s[::-1])}") print(f"Unicode reversed: {say_string(ureverse(s))}") print(f"Unicode reverse²: {say_string(ureverse(ureverse(s)))}")
if __name__ == '__main__':
ucode = .join(chr(int(n[2:], 16)) for n in 'U+0041 U+030A U+0073 U+0074 U+0072 U+006F U+0308 U+006D'.split()) say_rev(ucode)</lang>
- Output:
Input: Åström = LATIN CAPITAL LETTER A | COMBINING RING ABOVE | LATIN SMALL LETTER S | LATIN SMALL LETTER T | LATIN SMALL LETTER R | LATIN SMALL LETTER O | COMBINING DIAERESIS | LATIN SMALL LETTER M Character reversed: m̈orts̊A = LATIN SMALL LETTER M | COMBINING DIAERESIS | LATIN SMALL LETTER O | LATIN SMALL LETTER R | LATIN SMALL LETTER T | LATIN SMALL LETTER S | COMBINING RING ABOVE | LATIN CAPITAL LETTER A Unicode reversed: mörtsÅ = LATIN SMALL LETTER M | LATIN SMALL LETTER O | COMBINING DIAERESIS | LATIN SMALL LETTER R | LATIN SMALL LETTER T | LATIN SMALL LETTER S | LATIN CAPITAL LETTER A | COMBINING RING ABOVE Unicode reverse²: Åström = LATIN CAPITAL LETTER A | COMBINING RING ABOVE | LATIN SMALL LETTER S | LATIN SMALL LETTER T | LATIN SMALL LETTER R | LATIN SMALL LETTER O | COMBINING DIAERESIS | LATIN SMALL LETTER M
If this code is then used: <lang python>ucode = .join(chr(int(n[2:], 16)) for n in
'U+006B U+0301 U+0075 U+032D U+006F U+0304 U+0301 U+006E'.split())
say_rev(ucode)</lang> It produces this output
- Output:
Input: ḱṷṓn = LATIN SMALL LETTER K | COMBINING ACUTE ACCENT | LATIN SMALL LETTER U | COMBINING CIRCUMFLEX ACCENT BELOW | LATIN SMALL LETTER O | COMBINING MACRON | COMBINING ACUTE ACCENT | LATIN SMALL LETTER N Character reversed: ń̄o̭úk = LATIN SMALL LETTER N | COMBINING ACUTE ACCENT | COMBINING MACRON | LATIN SMALL LETTER O | COMBINING CIRCUMFLEX ACCENT BELOW | LATIN SMALL LETTER U | COMBINING ACUTE ACCENT | LATIN SMALL LETTER K Unicode reversed: nṓṷḱ = LATIN SMALL LETTER N | LATIN SMALL LETTER O | COMBINING MACRON | COMBINING ACUTE ACCENT | LATIN SMALL LETTER U | COMBINING CIRCUMFLEX ACCENT BELOW | LATIN SMALL LETTER K | COMBINING ACUTE ACCENT Unicode reverse²: ḱṷṓn = LATIN SMALL LETTER K | COMBINING ACUTE ACCENT | LATIN SMALL LETTER U | COMBINING CIRCUMFLEX ACCENT BELOW | LATIN SMALL LETTER O | COMBINING MACRON | COMBINING ACUTE ACCENT | LATIN SMALL LETTER N
This uses the unicode string mentioned in the task:
<lang python>ucode = .join(chr(int(n, 16))
for n in ['61', '73', '20dd', '64', '66', '305'])
say_rev(ucode)</lang> It produces this output
- Output:
Input: as⃝df̅ = LATIN SMALL LETTER A | LATIN SMALL LETTER S | COMBINING ENCLOSING CIRCLE | LATIN SMALL LETTER D | LATIN SMALL LETTER F | COMBINING OVERLINE Character reversed: ̅fd⃝sa = COMBINING OVERLINE | LATIN SMALL LETTER F | LATIN SMALL LETTER D | COMBINING ENCLOSING CIRCLE | LATIN SMALL LETTER S | LATIN SMALL LETTER A Unicode reversed: f̅d⃝sa = LATIN SMALL LETTER F | COMBINING OVERLINE | LATIN SMALL LETTER D | COMBINING ENCLOSING CIRCLE | LATIN SMALL LETTER S | LATIN SMALL LETTER A Unicode reverse²: as⃝df̅ = LATIN SMALL LETTER A | LATIN SMALL LETTER S | COMBINING ENCLOSING CIRCLE | LATIN SMALL LETTER D | LATIN SMALL LETTER F | COMBINING OVERLINE
Quackery
reverse is predefined (and applies to nests in general, including strings) as: <lang Quackery> [ dup nest? if
[ [] swap witheach [ nested swap join ] ] ] is reverse ( x --> x )</lang>
Qi
It's simplest just to use the common lisp REVERSE function. <lang Qi>(REVERSE "ABCD")</lang>
R
The following code works with UTF-8 encoded strings too. <lang R>revstring <- function(stringtorev) {
return( paste( strsplit(stringtorev,"")1[nchar(stringtorev):1] ,collapse="") )
}</lang>
Alternatively (using rev() function):
<lang R> revstring <- function(s) paste(rev(strsplit(s,"")1),collapse="")</lang>
<lang R>revstring("asdf") revstring("m\u00f8\u00f8se") Encoding("m\u00f8\u00f8se") # just to check if on your system it's something
# different!</lang>
- Output:
[1] "fdsa" [1] "esøøm" [1] "UTF-8"
R can encode strings in Latin1 and UTF-8 (the default may depend on the locale); the Encoding(string) can be used to know if the string is encoded in Latin1 or UTF-8; the encoding can be forced (Encoding(x) <- "latin1"), or we can use iconv to properly translate between encodings whenever possible.
Racket
As in Scheme:
<lang Racket>#lang racket
(define (string-reverse s)
(list->string (reverse (string->list s))))
(string-reverse "aoeu")</lang>
- Output:
Welcome to DrRacket, version 5.3.3.5--2013-02-20(5eddac74/d) [3m]. Language: racket; memory limit: 512 MB. "ueoa" >
Raku
(formerly Perl 6)
Raku handles graphemes, multi-byte characters and emoji correctly by default. <lang perl6>say "hello world".flip; say "as⃝df̅".flip; say 'ℵΑΩ 駱駝道 🤔 🇸🇧 🇺🇸 🇬🇧 👨👩👧👦🆗🗺'.flip;</lang>
- Output:
dlrow olleh f̅ds⃝a 🗺🆗👨👩👧👦 🇬🇧 🇺🇸 🇸🇧 🤔 道駝駱 ΩΑℵ
RapidQ
<lang vb> print reverse$("This is a test") </lang>
Rascal
<lang rascal>import String; reverse("string")</lang>
Raven
<lang Raven>"asdf" reverse</lang>
- Output:
fdsa
REBOL
<lang REBOL>print reverse "asdf"</lang> Note the string is reversed in place. If you were using it anywhere else, you would find it reversed: <lang REBOL>x: "asdf" print reverse x print x ; Now reversed.</lang> REBOL/View 2.7.6.3.1 14-Mar-2008 does not handle Unicode strings. This is planned for REBOL 3.
Red
<lang Red>>> reverse "asdf" == "fdsa"</lang>
Retro
<lang Retro>'asdf s:reverse s:put</lang>
REXX
All methods shown below also work with NULL values (strings with a zero length).
using REVERSE BIF
<lang rexx>/*REXX program to reverse a string (and show before and after strings).*/
string1 = 'A man, a plan, a canal, Panama!' string2 = reverse(string1)
say ' original string: ' string1 say ' reversed string: ' string2
/*stick a fork in it, we're done.*/</lang>
output
original string: A man, a plan, a canal, Panama! reversed string: !amanaP ,lanac a ,nalp a ,nam A
using SUBSTR BIF, left to right
<lang rexx>/*REXX program to reverse a string (and show before and after strings).*/
string1 = 'A man, a plan, a canal, Panama!' string2 =
do j=1 for length(string1) string2 = substr(string1,j,1)string2 end /*j*/
say ' original string: ' string1 say ' reversed string: ' string2
/*stick a fork in it, we're done.*/</lang>
output is identical to the 1st REXX version.
(Regarding the previous example) Another method of coding an abutment (an implied concatenation) is:
<lang rexx> string2 = substr(string1,j,1) || string2
/*───── or ─────*/ string2= substr(string1,j,1)string2</lang>
using SUBSTR BIF, right to left
<lang rexx>/*REXX program to reverse a string (and show before and after strings).*/
string1 = 'A man, a plan, a canal, Panama!' string2 =
do j=length(string1) to 1 by -1 string2 = string2 || substr(string1,j,1) end /*j*/
say ' original string: ' string1 say ' reversed string: ' string2
/*stick a fork in it, we're done.*/</lang>
output is identical to the 1st version.
Ring
<lang ring> cStr = "asdf" cStr2 = "" for x = len(cStr) to 1 step -1 cStr2 += cStr[x] next See cStr2 # fdsa </lang>
RLaB
<lang RLaB>>> x = "rosettacode" rosettacode
// script rx = ""; for (i in strlen(x):1:-1) {
rx = rx + substr(x, i);
}
>> rx edocattesor</lang>
Robotic
<lang robotic> . "local1 = Main string" . "local2 = Temporary string storage" . "local3 = String length" set "$local1" to "" set "$local2 " to "" set "local3" to 0
input string "String to reverse:" set "$local1" to "&INPUT&" set "$local2" to "$local1" set "local3" to "$local2.length" loop start set "$local1.(('local3' - 1) - 'loopcount')" to "$local2.('loopcount')" loop for "('local3' - 1)"
- "Reversed string: &$local1& (Length: &$local1.length&)"
end </lang>
Ruby
<lang ruby>str = "asdf" reversed = str.reverse</lang> or <lang ruby>#encoding: utf-8 "résumé niño".reverse #=> "oñin émusér"</lang> for extra credit <lang ruby> graphemes = 'as⃝df̅'.scan(/\X/) reversed = graphemes.reverse graphemes.join #=> "f̅ds⃝a" </lang>
Run BASIC
<lang runbasic>string$ = "123456789abcdefghijk" for i = len(string$) to 1 step -1
print mid$(string$,i,1);
next i</lang>
Rust
Reversing ASCII byte-slice (in-place):
<lang rust>let mut buffer = b"abcdef".to_vec(); buffer.reverse(); assert_eq!(buffer, b"fedcba");</lang>
Reversing Unicode scalar values:
<lang rust>let output: String = "一二三四五六七八九十".chars().rev().collect(); assert_eq!(output, "十九八七六五四三二一");</lang>
Reversing a Chars
iterator doesn't solve the complete problem, because it iterates unicode scalar values, which doesn't account for combining marks:
<lang rust>let output: String = "as⃝df̅".chars().rev().collect(); assert_ne!(output, "f̅ds⃝a"); // should be this assert_eq!(output, "̅fd⃝sa");</lang>
Reversing graphemes clusters, which is provided by the unicode-segmentation crate, solves the problem:
<lang rust>use unicode_segmentation::UnicodeSegmentation;
let output: String = "as⃝df̅".graphemes(true).rev().collect(); assert_eq!(output, "f̅ds⃝a");</lang>
S-lang
Here is an 8-bit version: <lang S-lang>variable sa = "Hello, World", aa = Char_Type[strlen(sa)+1]; init_char_array(aa, sa); array_reverse(aa); % print(aa);
% Unfortunately, strjoin() only joins strings, so we map char() % [sadly named: actually converts char into single-length string] % onto the array:
print( strjoin(array_map(String_Type, &char, aa), "") );</lang>
Output: "dlroW ,olleH"
For a Unicode version, we'll create a variant of init_char_array(). Side note: If needed, strbytelen() would give total length of string.
<lang S-lang>define init_unicode_array(a, buf) {
variable len = strbytelen(buf), ch, p0 = 0, p1 = 0; while (p1 < len) { (p1, ch) = strskipchar(buf, p1, 1); if (ch < 0) print("oops."); a[p0] = ch; p0++; }
}
variable su = "Σὲ γνωρίζω ἀπὸ τὴν κόψη"; variable au = Int_Type[strlen(su)+1]; init_unicode_array(au, su); array_reverse(au); % print(au); print(strjoin(array_map(String_Type, &char, au), "") );</lang>
Output: "ηψόκ νὴτ ὸπἀ ωζίρωνγ ὲΣ"
Note: The init...array() functions include the terminating '\0' chars, but we don't have to filter them out as char(0) produces a zero-length string.
SAS
<lang sas>data _null_; length a b $11; a="I am Legend"; b=reverse(a); put a; put b; run;</lang>
Sather
<lang sather>class MAIN is
main is s ::= "asdf"; reversed ::= s.reverse; -- current implementation does not handle multibyte encodings correctly end;
end;</lang>
Scala
Easy way: <lang scala>"asdf".reverse</lang>
Slightly less easy way: <lang scala>"asdf".foldRight("")((a,b) => b+a)</lang>
Unicode-aware, method 1:
<lang scala>def reverse(s: String) = {
import java.text.{Normalizer,BreakIterator} val norm = Normalizer.normalize(s, Normalizer.Form.NFKC) // waffle -> waffle (optional) val it = BreakIterator.getCharacterInstance it setText norm def break(it: BreakIterator, prev: Int, result: List[String] = Nil): List[String] = it.next match { case BreakIterator.DONE => result case cur => break(it, cur, norm.substring(prev, cur) :: result) } break(it, it.first).mkString
}</lang>
- Output:
scala> reverse("as⃝df̅") res0: String = f̅ds⃝a
Unicode-aware, method 2: I can't guarantee it get all the cases, but it does work with combining characters as well as supplementary characters. I did not bother to preserve the order of newline characters, and I didn't even consider directionality beyond just ruling it out. <lang scala>def reverseString(s: String) = {
import java.lang.Character._ val combiningTypes = List(NON_SPACING_MARK, ENCLOSING_MARK, COMBINING_SPACING_MARK) def isCombiningCharacter(c: Char) = combiningTypes contains c.getType def isCombiningSurrogate(high: Char, low: Char) = combiningTypes contains getType(toCodePoint(high, low)) def isCombining(l: List[Char]) = l match { case List(a, b) => isCombiningSurrogate(a, b) case List(a) => isCombiningCharacter(a) case Nil => true case _ => throw new IllegalArgumentException("isCombining expects a list of up to two characters") } def cleanSurrogate(l: List[Char]) = l match { case List(a, b) if a.isHighSurrogate && b.isLowSurrogate => l case List(a, b) if a.isLowSurrogate => Nil case List(a, b) => List(a) case _ => throw new IllegalArgumentException("cleanSurrogate expects lists of two characters, exactly") } def splitString(string: String) = (string+" ").iterator sliding 2 map (_.toList) map cleanSurrogate toList
def recurse(fwd: List[List[Char]], rev: List[Char]): String = fwd match { case Nil => rev.mkString case c :: rest => val (combining, remaining) = rest span isCombining recurse(remaining, c ::: combining.foldLeft(List[Char]())(_ ::: _) ::: rev) } recurse(splitString(s), Nil)
}</lang> REPL on Windows doesn't handle Unicode, so I'll show the bytes instead:
scala> res71 map ("\\u%04x" format _.toInt) res80: scala.collection.immutable.IndexedSeq[String] = IndexedSeq(\u0061, \u0073, \u20dd, \u0064, \u0066, \u0305) scala> reverseString(res71) map ("\\u%04x" format _.toInt) res81: scala.collection.immutable.IndexedSeq[String] = IndexedSeq(\u0066, \u0305, \u0064, \u0073, \u20dd, \u0061)
Scheme
<lang scheme>(define (string-reverse s)
(list->string (reverse (string->list s))))</lang>
> (string-reverse "asdf") "fdsa"
Scratch
Sed
<lang sed>#!/bin/sed -f
/../! b
- Reverse a line. Begin embedding the line between two newlines
s/^.*$/\ &\ /
- Move first character at the end. The regexp matches until
- there are zero or one characters between the markers
tx
- x
s/\(\n.\)\(.*\)\(.\n\)/\3\2\1/ tx
- Remove the newline markers
s/\n//g</lang>
Seed7
Seed7 strings are encoded with UTF-32 therefore no special Unicode solution is necessary <lang seed7>$ include "seed7_05.s7i";
const func string: reverse (in string: stri) is func
result var string: result is ""; local var integer: index is 0; begin for index range length(stri) downto 1 do result &:= stri[index]; end for; end func;
const proc: main is func
begin writeln(reverse("Was it a cat I saw")); end func;</lang>
- Output:
was I tac a ti saW
Self
In-place reversal: <lang self>'asdf' copyMutable reverse</lang>
SenseTalk
<lang sensetalk>put "asdf" reversed -- reverse on the fly
set imp to "rumpelstiltskin" reverse imp -- reverse in place put imp </lang>
- Output:
fdsa nikstlitslepmur
SequenceL
Using Library Function:
There is a library function to reverse any Sequence. This works for strings since strings are Sequences of characters. <lang sequencel>import <Utilities/Sequence.sl>;
main(args(2)) := Sequence::reverse(args[1]);</lang>
The Library Function:
The following is the library implementation of the reverse function. <lang sequencel>reverse<T> : T(1) -> T(1); reverse(list(1))[i] := let range := - ((1 ... size(list)) - (size(list) + 1)); in list[i] foreach i within range;</lang>
Sidef
<lang ruby>"asdf".reverse; # fdsa "résumé niño".reverse; # oñin émusér</lang>
Simula
<lang simula> BEGIN
TEXT PROCEDURE REV(S); TEXT S; BEGIN TEXT T; INTEGER L,R; T :- COPY(S); L := 1; R := T.LENGTH; WHILE L < R DO BEGIN CHARACTER CL,CR; T.SETPOS(L); CL := T.GETCHAR; T.SETPOS(R); CR := T.GETCHAR; T.SETPOS(L); T.PUTCHAR(CR); T.SETPOS(R); T.PUTCHAR(CL); L := L+1; R := R-1; END; REV :- T; END REV;
TEXT INP; INP :- "asdf";
OUTTEXT(INP); OUTIMAGE; OUTTEXT(REV(INP)); OUTIMAGE;
END </lang>
- Output:
asdf fdsa
Slate
In-place reversal: <lang slate>'asdf' reverse</lang> Non-destructive reversal: <lang slate>'asdf' reversed</lang>
Smalltalk
<lang smalltalk>'asdf' reverse</lang>
the above does inplace, destructive reverse. It is usually better to use <lang smalltalk>'asdf' reversed</lang> which returns a new string.
SNOBOL4
ASCII-only <lang snobol> output = reverse(reverse("reverse")) end</lang>
- Output:
reverse
Standard ML
<lang sml>val str_reverse = implode o rev o explode; val string = "asdf"; val reversed = str_reverse string;</lang>
Stata
Use strreverse if there are only ASCII characters, and ustrreverse if there are Unicode characters in the string.
<lang stata>. scalar s="ARS LONGA VITA BREVIS" . di strreverse(s) SIVERB ATIV AGNOL SRA . scalar s="Ἐν ἀρχῇ ἐποίησεν ὁ θεὸς τὸν οὐρανὸν καὶ τὴν γῆν" . di ustrreverse(s) νῆγ νὴτ ὶακ νὸναρὐο νὸτ ςὸεθ ὁ νεσηίοπἐ ῇχρἀ νἘ</lang>
Swift
Swift's strings are iterated by Character
s, which represent "Unicode grapheme clusters", so reversing it reverses it with combining characters too:
<lang swift>func reverseString(s: String) -> String {
return String(s.characters.reverse())
} print(reverseString("asdf")) print(reverseString("as⃝df̅"))</lang>
<lang swift>func reverseString(s: String) -> String {
return String(reverse(s))
} println(reverseString("asdf")) println(reverseString("as⃝df̅"))</lang>
- Output:
fdsa f̅ds⃝a
Symsyn
<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 []
</lang>
OR
<lang Symsyn> c : 'abcdefghijklmnopqrstuvwxyz'
c [] $s #c j if j > 0 - j + c.j $s 1 goif endif $s []
</lang>
- Output:
abcdefghijklmnopqrstuvwxyz zyxwvutsrqponmlkjihgfedcba
Tailspin
<lang tailspin> templates reverse
'$:[ $... ] -> $(last..first:-1)...;' !
end reverse
'asdf' -> reverse -> !OUT::write
' ' -> !OUT::write
'as⃝df̅' -> reverse -> !OUT::write </lang>
- Output:
fdsa f̅ds⃝a
Tcl
<lang tcl>package require Tcl 8.5 string reverse asdf</lang>
TI-83 BASIC
Note: length( and sub( can be found in the catalog. <lang ti83b>:Str1
- For(I,1,length(Ans)-1
- sub(Ans,2I,1)+Ans
- End
- sub(Ans,1,I→Str1</lang>
TMG
Unix TMG: <lang UnixTMG>prog: parse(str); str: smark any(!<<>>) scopy str/done = { 1 2 }; done: ;</lang>
Tosh
<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</lang>
Turing
Iterative solution, for character shovelers:
<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 reverse ("iterative example") put reverse (reverse ("iterative example"))</lang>
- Output:
elpmaxe evitareti iterative example
Recursive solution, more natural in Turing:
<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"))</lang>
- Output:
elpmaxe evisrucer recursive example
TUSCRIPT
<lang tuscript>$$ MODE TUSCRIPT SET input="was it really a big fat cat i saw" SET reversetext=TURN (input) PRINT "before: ",input PRINT "after: ",reversetext</lang>
- Output:
before: was it really a big fat cat i saw after: was i tac taf gib a yllaer ti saw
UNIX Shell
<lang bash>
- !/bin/bash
str=abcde
for((i=${#str}-1;i>=0;i--)); do rev="$rev${str:$i:1}"; done
echo $rev </lang>
or
<lang bash> str='i43go1342iu 23iu4o 23iu14i324y 2i13' rev <<< "$str"
- rev is not built-in function, though is in /usr/bin/rev
</lang>
Unlambda
Reverse the whole input: <lang Unlambda>``@c`d``s`|k`@c</lang>
Ursala
<lang Ursala>#import std
- cast %s
example = ~&x 'asdf'
verbose_example = reverse 'asdf'</lang>
- Output:
'fdsa'
Vala
<lang vala>int main (string[] args) { if (args.length < 2) { stdout.printf ("Please, input a string.\n"); return 0; } var str = new StringBuilder (); for (var i = 1; i < args.length; i++) { str.append (args[i] + " "); } stdout.printf ("%s\n", str.str.strip ().reverse ()); return 0; }</lang>
VBA
Non-recursive version
<lang VBA>Public Function Reverse(aString as String) as String ' returns the reversed string dim L as integer 'length of string dim newString as string
newString = "" L = len(aString) for i = L to 1 step -1
newString = newString & mid$(aString, i, 1)
next Reverse = newString End Function</lang>
Recursive version
<lang VBA>Public Function RReverse(aString As String) As String 'returns the reversed string 'do it recursively: cut the string in two, reverse these fragments and put them back together in reverse order Dim L As Integer 'length of string Dim M As Integer 'cut point
L = Len(aString) If L <= 1 Then 'no need to reverse
RReverse = aString
Else
M = Int(L / 2) RReverse = RReverse(Right$(aString, L - M)) & RReverse(Left$(aString, M))
End If End Function</lang>
Example dialogue
print Reverse("Public Function Reverse(aString As String) As String") gnirtS sA )gnirtS sA gnirtSa(esreveR noitcnuF cilbuP print RReverse("Sunday Monday Tuesday Wednesday Thursday Friday Saturday Love") evoL yadrutaS yadirF yadsruhT yadsendeW yadseuT yadnoM yadnuS print RReverse(Reverse("I know what you did last summer")) I know what you did last summer
VBScript
<lang VBScript> WScript.Echo StrReverse("asdf") </lang>
Vedit macro language
This routine reads the text from current line, reverses it and stores the reversed string in text register 10: <lang vedit>Reg_Empty(10) for (BOL; !At_EOL; Char) {
Reg_Copy_Block(10, CP, CP+1, INSERT)
}</lang> This routine reverses the current line in-place: <lang vedit>BOL while (!At_EOL) {
Block_Copy(EOL_pos-1, EOL_pos, DELETE)
}</lang>
Visual Basic
<lang vb>Debug.Print VBA.StrReverse("Visual Basic")</lang>
Visual Basic .NET
Compiler: >= Visual Basic 2012
Includes both a simple version and a version that uses .NET's built-in ability to enumerate strings by grapheme to support combining characters.
Since the windows console may not support Unicode, the program can optionally redirect its output to a file.
<lang vbnet>#Const REDIRECTOUT = True
Module Program
Const OUTPATH = "out.txt"
ReadOnly TestCases As String() = {"asdf", "as⃝df̅", "Les Misérables"}
' SIMPLE VERSION Function Reverse(s As String) As String Dim t = s.ToCharArray() Array.Reverse(t) Return New String(t) End Function
' EXTRA CREDIT VERSION Function ReverseElements(s As String) As String ' In .NET, a text element is series of code units that is displayed as one character, and so reversing the text ' elements of the string correctly handles combining character sequences and surrogate pairs. Dim elements = Globalization.StringInfo.GetTextElementEnumerator(s) Return String.Concat(AsEnumerable(elements).OfType(Of String).Reverse()) End Function
' Wraps an IEnumerator, allowing it to be used as an IEnumerable. Iterator Function AsEnumerable(enumerator As IEnumerator) As IEnumerable Do While enumerator.MoveNext() Yield enumerator.Current Loop End Function
Sub Main() Const INDENT = " "
- If REDIRECTOUT Then
Const OUTPATH = "out.txt" Using s = IO.File.Open(OUTPATH, IO.FileMode.Create), sw As New IO.StreamWriter(s) Console.SetOut(sw)
- Else
Try Console.OutputEncoding = Text.Encoding.ASCII Console.OutputEncoding = Text.Encoding.UTF8 Console.OutputEncoding = Text.Encoding.Unicode Catch ex As Exception Console.WriteLine("Failed to set console encoding to Unicode." & vbLf) End Try
- End If
For Each c In TestCases Console.WriteLine(c) Console.WriteLine(INDENT & "SIMPLE: " & Reverse(c)) Console.WriteLine(INDENT & "ELEMENTS: " & ReverseElements(c)) Console.WriteLine() Next
- If REDIRECTOUT Then
End Using
- End If
End Sub
End Module</lang>
- Output (copied from Notepad):
Output is presented using non-fixed-width typeface to properly display combining characters.
asdf SIMPLE: fdsa ELEMENTS: fdsa as⃝df̅ SIMPLE: ̅fd⃝sa ELEMENTS: f̅ds⃝a Les Misérables SIMPLE: selbaŕesiM seL ELEMENTS: selbarésiM seL
Wart
<lang wart>(rev "asdf")</lang>
Wart doesn't support Unicode yet.
Wren
<lang ecmascript>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())
}</lang>
- Output:
fdsa ésoj esøøm was I tac a ro rac a ti saw 🦊🚂😀 f̅ds⃝a 🗺🆗👨👩👧👦 🇬🇧 🇺🇸 🇸🇧 🤔 道駝駱 ΩΑℵ
Wortel
<lang wortel>; the @rev operator reverses strings and arrays @rev "abc" ; returns "cba"
- or the same thing using a pointer expression
!~r "abc"</lang>
XPL0
<lang XPL0>include c:\cxpl\codes; \intrinsic 'code' declarations string 0; \use zero-terminated strings, instead of MSb terminated
func StrLen(Str); \Return the number of characters in an ASCIIZ string char Str; int I; for I:= 0 to -1>>1-1 do
if Str(I) = 0 then return I;
func RevStr(S); \Reverse the order of the bytes in a string char S; int L, I, T; [L:= StrLen(S); for I:= 0 to L/2-1 do
[T:= S(I); S(I):= S(L-I-1); S(L-I-1):= T];
return S; ];
[Text(0, RevStr("a")); CrLf(0);
Text(0, RevStr("ab")); CrLf(0); Text(0, RevStr("abc")); CrLf(0); Text(0, RevStr("Able was I ere I saw Elba.")); CrLf(0);
]</lang>
Output:
a ba cba .ablE was I ere I saw elbA
Yorick
This only handles ASCII characters. It works by converting a string to an array of char; dropping the last character (which is the null byte); reversing the order of the characters; then converting back to a string. <lang yorick>strchar(strchar("asdf")(:-1)(::-1))</lang>
zkl
These only handle ASCII characters, no extra credit.
"this is a test".reverse()
Old school ways to do it:
Build by prepending characters, creates n strings:
"this is a test".reduce(fcn(p,c){c+p})
Convert to list, reverse, convert back to string:
"this is a test".split("").reverse().concat()
Write to a byte buffer and convert to string:
"this is a test".pump(Void,Data().insert.fp(0)).text
The ".fp(0)" creates a closure so each character is fed to data.insert(0,c). pump is a method that sends each character to a function to a sink (in this case /dev/null). The output is the result of the last call, which is data.insert which is self/data. https://en.wikipedia.org/wiki/Comparison_of_programming_languages_%28string_functions%29#reverseProperty "Wikipedia" (as page type) with input value "https://en.wikipedia.org/wiki/Comparison_of_programming_languages_%28string_functions%29#reverse" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process.
Zoea
<lang Zoea> program: reverse_string
input: xyzzy output: yzzyx
</lang>
Zoea Visual
- Programming Tasks
- String manipulation
- 0815
- 11l
- 360 Assembly
- 8080 Assembly
- 8th
- ACL2
- ActionScript
- Ada
- Agda
- Aime
- ALGOL 68
- Apex
- APL
- AppleScript
- Applesoft BASIC
- Arturo
- AutoHotkey
- AutoIt
- Avail
- AWK
- Babel
- BaCon
- BASIC
- IS-BASIC
- Sinclair ZX81 BASIC
- Batch File
- BBC BASIC
- Befunge
- Bracmat
- Brainf***
- Brat
- Burlesque
- C
- GLib
- C sharp
- C++
- Caché ObjectScript
- Ceylon
- Clipper
- Clojure
- COBOL
- CoffeeScript
- ColdFusion
- Common Lisp
- Component Pascal
- Cowgol
- Crystal
- D
- Dart
- DBL
- Dc
- Delphi
- DWScript
- Dyalect
- Déjà Vu
- E
- E examples needing attention
- EchoLisp
- EGL
- Eiffel
- Ela
- Elena
- Elixir
- Elm
- Emacs Lisp
- Erlang
- ERRE
- Euler Math Toolbox
- Euphoria
- Explore
- Ezhil
- F Sharp
- Factor
- FALSE
- Fancy
- FBSL
- Forth
- Fortran
- FreeBASIC
- Frink
- Futhark
- FutureBasic
- Gambas
- GAP
- Gema
- Genie
- GFA Basic
- Go
- Groovy
- Harbour
- Haskell
- HicEst
- Icon
- Unicon
- Io
- J
- Java
- JavaScript
- Jq
- Jsish
- Julia
- K
- Kotlin
- L++
- LabVIEW
- Lambdatalk
- Lang5
- Langur
- Lasso
- LC3 Assembly
- LFE
- Liberty BASIC
- Lingo
- LiveCode
- LLVM
- Logo
- Lua
- M2000 Interpreter
- M4
- Maclisp
- Maple
- Mathematica
- Wolfram Language
- MATLAB
- Maxima
- MAXScript
- Min
- MiniScript
- MIPS Assembly
- Mirah
- Modula-2
- Modula-3
- MUMPS
- Nanoquery
- Neko
- Nemerle
- NetRexx
- NewLISP
- Nial
- Nim
- NS-HUBASIC
- Oberon
- Objeck
- Objective-C
- OCaml
- Octave
- Oforth
- Ol
- OOC
- OpenEdge/Progress
- OxygenBasic
- Oz
- PARI/GP
- Pascal
- Peloton
- Perl
- Pharo
- Phix
- PHP
- PicoLisp
- Pike
- PL/I
- Plain English
- PlainTeX
- Pop11
- PostScript
- PowerBASIC
- PowerShell
- Prolog
- PureBasic
- Python
- Quackery
- Qi
- R
- Racket
- Raku
- RapidQ
- Rascal
- Raven
- REBOL
- Red
- Retro
- REXX
- Ring
- RLaB
- Robotic
- Ruby
- Run BASIC
- Rust
- S-lang
- SAS
- Sather
- Scala
- Scheme
- Scratch
- Sed
- Seed7
- Self
- SenseTalk
- SequenceL
- Sidef
- Simula
- Slate
- Smalltalk
- SNOBOL4
- Standard ML
- Stata
- Swift
- Symsyn
- Tailspin
- Tcl
- TI-83 BASIC
- TMG
- Tosh
- Turing
- TUSCRIPT
- UNIX Shell
- Unlambda
- Ursala
- Vala
- VBA
- VBScript
- Vedit macro language
- Visual Basic
- Visual Basic .NET
- Wart
- Wren
- Wren-str
- Wren-upc
- Wortel
- XPL0
- Yorick
- Zkl
- Bc/Omit
- Dc/Omit
- Openscad/Omit
- Zoea
- Zoea Visual