Reverse a string: Difference between revisions

=={{header|0815}}==

This program reverses each line of its input.

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

<:a:=- Stop reading on newline.

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

^:p:

 

{{out}}

 

oof

 

=={{header|11l}}==

 

=={{header|360 Assembly}}==

For maximum compatibility, this program uses only the basic instruction set (S/360)

and an ASSIST macro (XPRNT) to keep the code as short as possible.

REVERSE CSECT

USING REVERSE,R13 base register

TMP DS CL12

REGEQU

{{out}}

<pre>

</pre>

This second example uses MVCIN introduced in S/370 architecture.

REVERSEI CSECT

USING REVERSEI,R13 base register

BB DS CL(L'AA) b

REGEQU

{{out}}

<pre>

 

 

jmp test

 

pop h

inx h

 

=={{header|8th}}==

In 8th strings are UTF-8 and the language retains characters per-se:

"abc" s:rev

{{out}}

<tt>"cba"</tt>

 

=={{header|ACL2}}==

 

ACL2 does not support unicode.

 

=={{header|Action!}}==

BYTE i,j

 

Test("123456789")

Test("!noitcA iratA")

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Reverse_a_string.png Screenshot from Atari 8-bit computer]

 

=={{header|ActionScript}}==

{

var reversed:String = new String();

{

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

 

=={{header|Ada}}==

procedure Reverse_String is

begin

Put_Line (Reverse_It (Get_Line));

 

=={{header|Agda}}==

 

 

 

=={{header|Aime}}==

 

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

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

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

FOR i TO UPB s OVER 2 DO

CHAR c = s[i];

reverse(text);

print((text, new line))

{{out}}

<pre>

 

=={{header|Amazing Hopper}}==

#include <hopper.h>

 

reverse(s),strtoutf8, println

{0}return

{{out}}

<pre>

</pre>

=={{header|Apex}}==

String str = 'Hello World!';

str = str.reverse();

system.debug(str);

 

=={{header|APL}}==

 

=={{header|AppleScript}}==

{{works with |AppleScript| 2.0 or newer.}}

 

on reverseString(str)

reverse of characters of str as string

 

'''NB.''' Since coercing lists to string involves the interpolation of the current value of AppleScript's text item delimiters between the list items, it's considered best practice to set the delimiters ''explicitly'' to their default value of <code>{""}</code> (or just <code>""</code>) before doing an operation like this, in case they've been set to something else elsewhere in the script:

 

 

on reverseString(str)

set AppleScript's text item delimiters to astid

return reversedString

----

Or, if we want a polymorphic '''reverse()''' for both strings and lists, we can define it either in terms of a generic fold/reduce, or using the built-in method for lists:

 

 

-- reverse1 :: [a] -> [a]

end script

end if

 

{{Out}}

 

=={{header|Arturo}}==

 

 

{{out}}

=={{header|AutoHotkey}}==

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

 

reverse(string)

reversed := A_LoopField . reversed

Return reversed

; <nowiki>A ''much'' slower version:</nowiki>

If (A_IsUnicode){

SLen := StrLen(String) * 2

Return RString

 

=={{header|AutoIt}}==

$mystring="asdf"

$reverse_string = ""

Next

 

 

=={{header|Avail}}==

 

=={{header|AWK}}==

{

p = ""

BEGIN {

print reverse("edoCattesoR")

 

;Recursive

{

l = length(s)

BEGIN {

print reverse("edoCattesoR")

 

;using split, then joining in front:

 

function rev(s, i,len,a,r) {

print s, "<-->", rev(s)

}

{{out}}

Rosetta <--> attesoR

=={{header|Babel}}==

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

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

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

 

=={{header|BaCon}}==

s$ = "asdf"

 

Unicode preservation works in BaCon 3.6 and higher.

 

=={{header|BASIC}}==

 

==={{header|IS-BASIC}}===

120 LET REV$=""

130 FOR I=LEN(TX$) TO 1 STEP-1

140 LET REV$=REV$&TX$(I)

150 NEXT

 

==={{header|Sinclair ZX81 BASIC}}===

20 LET T$=""

30 FOR I=LEN S$ TO 1 STEP -1

40 LET T$=T$+S$(I)

50 NEXT I

 

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

setlocal enabledelayedexpansion

call :reverse %1 res

set str=%str:~1%

set %2=%chr%!%2!

 

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

END

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

NEXT

 

=={{header|Befunge}}==

Reads a line from stdin and write the reverse to stdout. Can be made to repeat indefinitely by removing the final <tt>@</tt> command.

 

 

=={{header|Bracmat}}==

= L x

. :?L

| str$!L

)

{{out}}

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

 

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

Another solution:

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

 

just because it looks good we print CRLF

 

=={{header|Brat}}==

 

=={{header|Burlesque}}==

 

"Hello, world!"<-

 

=={{header|C}}==

#include <stdlib.h>

#include <locale.h>

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

return 0;

{{out}}

<pre>abcdef => fedcba

 

{{libheader|GLib}}

gchar *srev (const gchar *s) {

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

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

return 0;

 

=={{header|C sharp}}==

C# does not have a built-in Reverse method for strings, and cannot reverse them in place because they are immutable. One way to implement this is to convert the string to an array of characters, reverse that, and return a new string from the reversed array:

{

char[] inputChars = input.ToCharArray();

Array.Reverse(inputChars);

return new string(inputChars);

 

As of .Net 3.5 the LINQ-to-objects allows the Reverse() extension method to be called on a string, since String implements the IEnumerable<char> interface. Because of this, the return type of Reverse is IEnumerable<char>. Fortunately, LINQ also provides the ToArray extension method, which can be used in conjunction with the constructor of string that accepts a char array:

 

// ...

return new string(input.Reverse().ToArray());

 

 

'''Version supporting combining characters:'''

 

System.Globalization.StringInfo provides a means of separating a string into individual graphemes.

{

// In .NET, a text element is series of code units that is displayed as one character, and so reversing the text

while (enumerator.MoveNext())

yield return enumerator.Current;

 

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

#include <algorithm>

 

std::string s;

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

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

 

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

 

=={{header|Ceylon}}==

shared void run() {

 

}

}

 

=={{header|Clipper}}==

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

LOCAL sOut := "", i

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

sOut += Substr(sIn, i, 1)

NEXT

 

=={{header|Clojure}}==

=== A Simple implementation with the magic of "conj" function ===

 

(defn reverse-string [s]

"Returns a string with all characters in reverse"

(apply str (reduce conj '() s)))

 

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

 

 

=== Supporting combining characters ===

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

(let [type (Character/getType c)]

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

"Unicode-safe string reverse"

[s]

{{out}}

<pre>

 

=={{header|CLU}}==

rslt: array[char] := array[char]$predict(1,string$size(s))

for c: char in string$chars(s) do

po: stream := stream$primary_output()

stream$putl(po, reverse("!dlrow ,olleH"))

{{out}}

<pre>Hello, world!</pre>

 

=={{header|COBOL}}==

 

=={{header|CoffeeScript}}==

 

=={{header|ColdFusion}}==

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

 

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

 

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

BlackBox Component Builder

MODULE BbtReverseString;

IMPORT StdLog;

END Do;

END BbtReverseString.

Execute: ^Q BbtReverseString.Do<br/>

{{Out}}

 

=={{header|Cowgol}}==

include "strings.coh";

 

var str: [uint8] := "\nesreveR";

CopyString(str, &buf[0]);

 

{{out}}

 

=={{header|Crystal}}==

 

strings = ["asdf", "as⃝df̅"]

strings.each do |s|

puts "#{s} -> #{s.reverse}"

 

{{out}}

 

=={{header|D}}==

import std.range, std.conv;

 

dstring s4 = "hello"d;

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

 

=={{header|Dart}}==

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

 

 

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

 

 

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

});

});

 

 

=={{header|DBL}}==

STR_OUT=

FOR J=%TRIM(STR_IN) STEP -1 UNTIL 1

STR_OUT(K:1)=STR_IN(J:1)

END

 

 

Reversing "Hello world!" which is "22405534230753963835153736737" in Dc's numerical string representaion.<br>

Due to using "~" this example needs GNU Dc or OpenBSD Dc.

<pre>

!dlrow olleH

 

=={{header|Delphi}}==

var

i: integer;

for i := Length(InString) downto 1 do

Result := Result + InString[i];

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

 

Another alternative.

function Reverse(const s: string): string;

var

result[aLength - i + 1] := c;

end;

All versions has the same perfomance, then StrUtils is recomended.

 

=={{header|DWScript}}==

=={{header|Dyalect}}==

 

var cs = []

for n in 1..len {

}

String(values: cs)

}

 

=={{header|Déjà Vu}}==

{{out}}

<pre>olleH</pre>

 

=={{header|E}}==

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

def reverse(string) {

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

 

=={{header|EchoLisp}}==

(define (string-reverse string)

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

(string-reverse "un roc lamina l animal cornu")

→ unroc lamina l animal cor nu

 

=={{header|EGL}}==

result string;

for ( i int from StrLib.characterLen( str ) to 1 decrement by 1 )

end

return( result );

 

=={{header|Eiffel}}==

APPLICATION

create

my_string: STRING

-- Used for reversal

{{out}}

<pre>

 

=={{header|Ela}}==

where len = length str

rev 0 str = ""

where nn = n - 1

 

 

{{out}}<pre>"olleH"</pre>

Another approach is to covert a string to a list, reverse a list and then convert it back to a string:

 

 

=={{header|Elena}}==

ELENA 4.x:

import extensions;

import extensions'text;

{

console.printLine("Hello World".reversedLiteral())

{{out}}

<pre>

=={{header|Elixir}}==

Elixir handles Unicode graphemes correctly by default.

IO.puts (String.reverse "asdf")

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

{{Out}}

<pre>

 

=={{header|Elm}}==

 

 

 

 

 

 

 

=={{header|Emacs Lisp}}==

{{out}}

<pre>

 

=={{header|Erlang}}==

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

Size = size(Bin)*8,

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

{{out}}

<pre>

 

=={{header|ERRE}}==

PROGRAM REVERSE_STRING

 

PRINT(R$)

END PROGRAM

 

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

 

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

>strrev("This is a test!")

!tset a si sihT

 

=={{header|Euphoria}}==

 

include std/sequence.e

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

 

=={{header|Explore}}==

 

=={{header|Ezhil}}==

 

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

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

 

 

=={{header|F_Sharp|F#}}==

===The function===

// 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 ""

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

printfn "%s" (strRev "as⃝df̅")

printfn "%s" (strRev "Nigel")

{{out}}

<pre>

=={{header|Factor}}==

A string is a sequence and there is a default reverse implementation for those.

<code>string-reverse</code> preserves graphemes:

 

=={{header|FALSE}}==

This solution does not take into account combination characters:

[^$1_=~][]#%

This solution does take into account combination characters (except for half-marks):

[^$1_=~][

$$767>\879\>&

[\]?

]#%

 

=={{header|Fancy}}==

 

=={{header|FBSL}}==

A slow way

dim $b = ""

REPEAT len(p1)

return b

End Function

 

A much faster (twice at least) way

dim $b = "", %i

for i = len(p1) DOWNTO 1

next

return b

 

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

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

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

RETURN s

end function

 

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

void rev(char *str)

{

return theString;

}

 

Using DynASM, the Dynamic Assembler mode.

// get length of string

// divide by two

RET

END DYNASM

 

=={{header|Forth}}==

 

=== Method 1 ===

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

: reverse ( c-addr u -- )

repeat 2drop ;

 

 

=== Method 2 Using the stack ===

 

: 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 ;

 

Forth Console Output

The xchars wordset offers several ways to skin this cat; this is just one way to do it, not necessarily the best one. Because the xchars wordset currently does not support recognizing combining characters, this code does not get extra credit.

 

u allocate throw u + c-addr swap over u + >r begin ( from to r:end)

over r@ u< while

 

\ example use

 

=={{header|Fortran}}==

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

 

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

WRITE(*,*) str

 

{{out}}

This is a string

gnirts a si sihT

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

 

implicit none

end function reverse

 

{{out}}

<pre>no devil lived on

 

Another shorter implementation (adapted version from stackoverflow question 10605574 how-to-reverse-a-chain-of-character-fortran-90):

implicit none

character (80) :: cadena

write (*,*) cadena

!

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

 

Function ReverseString(s As Const String) As String

 

Dim s As String = "asdf"

 

{{out}}

 

For example, the string "g\u0308o" represents a g with combining diaeresis, followed by the letter o. Or, in other words, "g̈o". Note that while there are three Unicode codepoints, only two "graphemes" are displayed. Using Frink's smart "reverse" function preserves these combined graphemes. A naive reverse would move the diaeresis over the o instead of the g.

 

=={{header|Futhark}}==

Futhark has no real strings beyond a little bit of syntactic sugar, so this is the same as reversing an array.

 

fun main(s: []i32) = s[::-1]

 

=={{header|FutureBasic}}==

 

 

 

 

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=e32989a1ffdc4428075ca6d4cb15dfa6 Click this link to run this code]'''

Dim sString As String = "asdf"

Dim sOutput As String

Print sOutput

Output:

<pre>

 

=={{header|GAP}}==

 

=={{header|Gema}}==

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

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

 

=={{header|Genie}}==

Pretty sure the output capture fails the extra credit, but that may be more local setup and font installs rather than the glib functions used.

 

/*

Reverse a string, in Genie

 

print combining

 

{{out}}

=={{header|GFA Basic}}==

 

PRINT @reverse$("asdf")

'

RETURN result$

ENDFUNC

 

=={{header|Go}}==

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

 

import (

r = reversePreservingCombiningCharacters(s)

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

{{out}}

<pre>

=={{header|Groovy}}==

=====Solution:=====

{{out}}

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

 

=====Extra Credit:=====

 

List combiningBlocks = [

}

}

{{out}}

<pre>f̅ds⃝a</pre>

 

=={{header|Harbour}}==

 

LOCAL cOut := "", i

NEXT

 

 

=={{header|Haskell}}==

This function as defined in the Haskell Prelude.

 

 

Perhaps, for example:

accumulatingReverse lst =

let rev xs a = foldl (flip (:)) a xs

 

===Supporting combining characters===

import Data.List (groupBy)

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

 

=={{header|HicEst}}==

 

L = LEN( string )

ENDDO

 

 

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

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

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

 

=={{header|Io}}==

 

=={{header|J}}==

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

Extra credit:

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

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

 

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

 

=={{header|Java}}==

 

=={{header|JavaScript}}==

 

 

function reverseStr(s) {

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

while (i--) o += s[i];

return o;

 

 

 

// .reduceRight() can be useful when reversals

.map(f => f("Some string to be reversed"));

 

 

{{Out}}

 

=={{header|jq}}==

jq's explode/implode filters are based on codepoints, and therefore "reverse_string" as defined here will reverse the sequence of codepoints.

The topic of Unicode combining characters is a large one that is not touched on here.

'''Examples''':

"nöel" | reverse_string # => "leön"

 

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

puts(str);

{{out}}

<pre>Never odd or even

 

=={{header|Julia}}==

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

 

=={{header|K}}==

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

|"asdf"

"fdsa"

| 23 4 5 1

1 5 4 23

 

=={{header|Kotlin}}==

println("asdf".reversed())

 

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

(main

(decl std::string s)

(std::getline std::cin s)

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

 

=={{header|LabVIEW}}==

 

=={{header|Lambdatalk}}==

{S.reverse hello brave new world}

-> world new brave hello

 

=={{header|Lang5}}==

 

=={{header|langur}}==

 

{{out}}

 

=={{header|Lasso}}==

 

===Using Query Expression & Array===

More verbose than the string->reverse method, but this example illustrates different techniques to achieve the same result:

using string->values to iterate over a string in order, inserting at position 1, and joining the resulting array as a string.

with i in #input->values

do #output->insertFirst(#i)

 

=={{header|LC3 Assembly}}==

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

 

LEA R1,STRING

GNIRTS .BLKW 128

 

{{out}}

<pre>d'gnahc woh !n'llaf woh O tub -- eh tseeb uoht fI</pre>

 

Ordinary string:

> (lists:reverse "asdf")

"fdsa"

 

Create a UTF-8 encoded string:

> (set encoded (binary ("åäö ð" utf8)))

#B(195 165 195 164 195 182 32 195 176)

 

Display it, to be sure:

> (io:format "~tp~n" (list encoded))

<<"åäö ð"/utf8>>

 

Reverse it:

> (lists:reverse (unicode:characters_to_list encoded))

"ð öäå"

 

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

print input$

print ReversedStr$( input$)

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

next i

 

=={{header|Lingo}}==

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

res = ""

repeat with i = str.length down to 1

end repeat

return res

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

ba = byteArray(str)

res = byteArray()

end repeat

return res

 

=={{header|LiveCode}}==

repeat with i = length(S) down to 1

put char i of S after R

end repeat

return R

 

=={{header|LLVM}}==

; LLVM does not provide a way to print values, so the alternative would be

; to just load the string into memory, and that would be boring.

declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32, i1)

 

{{out}}

<pre>Hello world

=={{header|Logo}}==

REVERSE works on both words and lists.

 

=={{header|Lua}}==

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

 

=={{header|M2000 Interpreter}}==

===Using Custom Function===

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

Module ReverseString {

a$="as⃝df̅"

}

ReverseString

 

===using StrRev$()===

this function (new to 9.5 version) use StrReverse from Vb6

a$="as⃝df̅"

b$=strrev$(a$)

clipboard b$

Print b$="̅fd⃝sa"

 

=={{header|M4}}==

 

=={{header|Maclisp}}==

Output:

<pre>"gnirts-ym"</pre>

 

=={{header|Maple}}==

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

 

=={{header|MATLAB}}==

 

Sample Usage:

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

 

ans =

 

 

=={{header|Maxima}}==

 

 

=={{header|MAXScript}}==

(

local reversed = ""

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

reversed

 

=={{header|min}}==

{{works with|min|0.19.3}}

 

=={{header|MiniScript}}==

print "Forward: " + str

newStr = ""

newStr = newStr + str[i]

end for

{{out}}

<pre>

=={{header|MIPS Assembly}}==

 

# First, it gets the length of the original string

# Then, it allocates memory from the copy

ex_msg_cpy: .asciiz "\nCopied string:\n"

string: .asciiz "Nice string you got there!\n"

 

=={{header|Mirah}}==

StringBuilder.new(s).reverse

end

 

 

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

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT Write,WriteString,WriteLn,ReadChar;

 

ReadChar

 

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

 

IMPORT IO, Text;

BEGIN

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

{{out}}

<pre>

 

=={{header|MUMPS}}==

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

NEW S

READ:30 "Enter a string: ",S

WRITE !,$REVERSE(S)

{{out}}

<pre>

 

=={{header|Nanoquery}}==

l = ""

 

 

return l

 

=={{header|Neko}}==

No extra credit for UTF in this example.

 

var reverse = function(s) {

str = ""

$print(str, "\n")

{{out}}

<pre>prompt$ nekoc reverse.neko

===Supporting Combining Characters===

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

using System.Globalization;

using System.Windows.Forms;

MessageBox.Show($"$test --> $(UReverse(test))"); //for whatever reason my console didn't display Unicode properly, but a MessageBox worked

}

===Basic Reverse===

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

{

mutable output = [];

output ::= c.ToString();

Concat("", output)

 

=={{header|NetRexx}}==

 

options replace format comments java crossref savelog symbols nobinary

say sihTesrever

 

{{out}}

<pre>

 

=={{header|NewLISP}}==

 

=={{header|Nial}}==

 

=={{header|Nim}}==

 

 

 

 

 

 

 

 

=={{header|NS-HUBASIC}}==

20 REVERSED$=""

30 FOR I=1 TO LEN(STRING$)

40 REVERSED$=MID$(STRING$,I,1)+REVERSED$

50 NEXT

 

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

 

IMPORT Out, Strings;

Out.String(s);

Out.Ln

 

=={{header|Objeck}}==

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

 

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

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

 

@interface NSString (Extended)

return rtr;

}

Usage example:

{

@autoreleasepool {

}

return 0;

===Supporting combining characters===

Extra credit

 

@interface NSString (Extended)

return ostr;

}

Usage example:

{

@autoreleasepool {

}

return 0;

 

=={{header|OCaml}}==

 

{{works with|OCaml|4.02+}}

let len = String.length s in

String.init len (fun i -> s.[len - 1 - i])

 

let () =

 

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

 

let last = Bytes.length bs - 1 in

for i = 0 to last / 2 do

print_bytes s;

print_newline ();

 

Here is a 100% functionnal string reversing function:

if List.length list = String.length strin

then String.concat "" list

 

let () =

 

will return "!dlroW olleH"

 

=={{header|Octave}}==

 

=={{header|Oforth}}==

 

=={{header|Ol}}==

(define (rev s)

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

(print (rev "Hello, λ!"))

; ==> !λ ,olleH

 

=={{header|OOC}}==

main: func {

"asdf" reverse() println() // prints "fdsa"

}

 

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

INPUT i_c AS CHARACTER

):

END FUNCTION.

 

 

=={{header|OxygenBasic}}==

 

'8 BIT CHARACTERS

'

print s

 

==OxygenBasic x86 Assembler==

32 bit code, 8-bit characters:

 

string s="qwertyuiop"

 

print s

 

=={{header|Oz}}==

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

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

fun {DoReverse Xs Ys}

case Xs of nil then Ys

in

fun {Reverse Xs} {DoReverse Xs nil} end

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

 

 

===Version #1.===

 

===Version #2.===

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

 

\\ Return reversed string str.

\\ 3/3/2016 aev

for(i=1,n, sr=sreverse(s));

}

 

{{Output}}

</pre>

 

\\ Version #1 upgraded to complete function. Practically the same.

reverse(str)={return(concat(Vecrev(str)))}

for(i=1,n, sr=reverse(s));

}

 

{{Output}}

 

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

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

var

for i := 0 to len-1 do

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

function revstr(my_s:string):string;

var out_s:string;

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

revstr:=out_s;

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

var i:integer;

var tmp:char;

reverse:=s;

end;

alternative as procedure which changes the original

var

i,j:integer;

dec(j)

end;

 

=={{header|Peloton}}==

Padded out, variable length Chinese dialect

This assigns the reverse of 'the cat sat on the mat' to the variable 'container' and displays the result which is <pre>子垫在坐猫</pre> which Google Translate renders as <pre>Sub-pad sitting cat</pre>.

 

The same again but with everything in Korean.

Reversing the Korean makes an untranslatable-by-Google mess of the sentence, viz <pre>아앉 에위 트매 가이양고</pre>.

 

The short-opcode version in English dialect is

Peloton works in Unicode.

 

=={{header|Perl}}==

binmode STDOUT, ":utf8";

 

# to reverse characters (code points):

 

# to reverse graphemes:

 

$string = 'ℵΑΩ 駱駝道 🤔 🇸🇧 🇺🇸 🇬🇧‍ 👨‍👩‍👧‍👦🆗🗺';

{{out}}

<pre>rosiv

 

=={{header|Pharo}}==

 

 

=={{header|Phix}}==

Note that [[XXXX_redacted#Phix]] adds some ZERO-WIDTH-JOINER handling to the inner code.

 

=={{header|PHP}}==

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

 

=={{header|PicoLisp}}==

{{out}}

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

=={{header|Pike}}==

For simple ASCII:

{{out}}

<pre>"oof"</pre>

if sent raw wide strings.

 

void main()

{

string s = "ßÜÖÄüöää ἀρχῇ";

write("%s\n", string_to_utf8( reverse(s) ));

{{out}}

<pre>

 

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

 

=={{header|Plain English}}==

Start up.

Put "asdf" into a string.

Reverse the string.

 

=={{header|plainTeX}}==

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

 

\def\reverse#1{\reversei{}#1\revA\revB\revB\revB\revB\revB\revB\revB\revB\revA}

\def\reversei#1#2#3#4#5#6#7#8#9{\gobtoB#9\revend\revB\reversei{#9#8#7#6#5#4#3#2#1}}

\def\revend\revB\reversei#1#2\revA{\gobtoA#1}

\reverse{Rosetta}

 

Output:

 

=={{header|Pop11}}==

lvars i, l = length(s);

for i from l by -1 to 1 do

endfor;

consstring(l);

 

=={{header|PostScript}}==

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

/str exch def

/temp str 0 get def

}repeat

str pstack

{{Out}}

[3 2 1]

 

(Hello World) reverse % input

 

=={{header|PowerBASIC}}==

#COMPILER PBCC 6

 

FUNCTION PBMAIN () AS LONG

CON.PRINT STRREVERSE$("PowerBASIC")

 

=={{header|PowerShell}}==

Test string

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

{{works with|PowerShell|1}}

{{works with|PowerShell|2}}

{{works with|PowerShell|2}}

Creating a regular expression substitution which captures every character of the string in a capture group and uses a reverse-ordered string of references to those to construct the reversed string.

{{works with|PowerShell|1}}

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

{{works with|PowerShell|2}}

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

{{works with|PowerShell|3}}

 

=={{header|Prolog}}==

{{works with|SWI Prolog}}

{{Out}}

<pre>

The main workings are hidden inside the reverse/2 predicate,

so lets write one to see how it works:

accRev([], A, A).

 

 

=={{header|PureBasic}}==

 

=={{header|Python}}==

===Optimized for user input===

 

===Already known string===

or

 

===Python: Unicode reversal===

 

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

 

def ureverse(ustring):

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

 

{{out}}

 

If this code is then used:

'U+006B U+0301 U+0075 U+032D U+006F U+0304 U+0301 U+006E'.split())

It produces this output

{{out}}

 

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

for n in ['61', '73', '20dd', '64', '66', '305'])

It produces this output

{{out}}

=={{header|Quackery}}==

reverse is predefined (and applies to nests in general, including strings) as:

[ [] swap witheach

[ nested

 

 

=={{header|Qi}}==

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

 

=={{header|R}}==

{{works with|R|2.8.1}}

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

return(

paste(

,collapse="")

)

 

Alternatively (using rev() function):

 

 

revstring("m\u00f8\u00f8se")

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

{{out}}

<pre>

As in Scheme:

 

 

(define (string-reverse s)

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

 

 

{{out}}

{{Works with|rakudo|2018.08}}

Raku handles graphemes, multi-byte characters and emoji correctly by default.

say "as⃝df̅".flip;

{{out}}

<pre>dlrow olleh

 

=={{header|RapidQ}}==

print reverse$("This is a test")

 

=={{header|Rascal}}==

 

=={{header|Raven}}==

{{out}}

<pre>fdsa</pre>

 

=={{header|REBOL}}==

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

print reverse x

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

 

=={{header|Red}}==

 

=={{header|ReScript}}==

let len = Js.String2.length(s)

let arr = []

}

 

{{out}}

<pre>

 

=={{header|Retro}}==

 

=={{header|REXX}}==

All methods shown below also work with &nbsp; '''NULL''' &nbsp; values &nbsp; (strings with a zero length).

===using REVERSE BIF===

 

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

say ' original string: ' string1

say ' reversed string: ' string2

'''output'''

<pre>

 

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

 

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

say ' original string: ' string1

say ' reversed string: ' string2

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

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

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

 

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

 

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

say ' original string: ' string1

say ' reversed string: ' string2

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

<br><br>

 

=={{header|Ring}}==

cStr = "asdf" cStr2 = ""

for x = len(cStr) to 1 step -1 cStr2 += cStr[x] next

See cStr2 # fdsa

 

=={{header|RLaB}}==

rosettacode

 

 

>> rx

 

=={{header|Robotic}}==

. "local1 = Main string"

. "local2 = Temporary string storage"

* "Reversed string: &$local1& (Length: &$local1.length&)"

end

 

=={{header|Ruby}}==

for extra credit

graphemes = 'as⃝df̅'.scan(/\X/)

reversed = graphemes.reverse

graphemes.join #=> "f̅ds⃝a"

 

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

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

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

 

=={{header|Rust}}==

Reversing ASCII byte-slice (in-place):

 

buffer.reverse();

 

Reversing Unicode scalar values:

 

 

Reversing a <code>Chars</code> iterator doesn't solve the complete problem, because it iterates unicode scalar values, which doesn't account for combining marks:

 

assert_ne!(output, "f̅ds⃝a"); // should be this

 

Reversing graphemes clusters, which is provided by the [https://unicode-rs.github.io/unicode-segmentation/unicode_segmentation/struct.Graphemes.html unicode-segmentation] crate, solves the problem:

 

 

let output: String = "as⃝df̅".graphemes(true).rev().collect();

 

=={{header|S-lang}}==

Here is an 8-bit version:

init_char_array(aa, sa);

array_reverse(aa);

% onto the array:

 

Output: "dlroW ,olleH"

Side note: If needed, strbytelen() would give total length of string.

 

{

variable len = strbytelen(buf), ch, p0 = 0, p1 = 0;

array_reverse(au);

% print(au);

 

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

 

=={{header|SAS}}==

length a b $11;

a="I am Legend";

put a;

put b;

 

=={{header|Sather}}==

main is

s ::= "asdf";

-- current implementation does not handle multibyte encodings correctly

end;

 

=={{header|Scala}}==

Easy way:

 

Slightly less easy way:

 

Unicode-aware, method 1:

 

import java.text.{Normalizer,BreakIterator}

val norm = Normalizer.normalize(s, Normalizer.Form.NFKC) // waffle -> waffle (optional)

}

break(it, it.first).mkString

{{out}}

<pre>scala> reverse("as⃝df̅")

 

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

import java.lang.Character._

}

recurse(splitString(s), Nil)

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

<pre>

 

=={{header|Scheme}}==

 

> (string-reverse "asdf")

 

=={{header|Sed}}==

 

/../! b

 

# Remove the newline markers

 

=={{header|Seed7}}==

 

result

var string: result is "";

const proc: main is func

begin

<pre>

was I tac a ti saW

=={{header|Self}}==

In-place reversal:

 

=={{header|SenseTalk}}==

 

set imp to "rumpelstiltskin"

reverse imp -- reverse in place

put imp

{{out}}

<pre>

 

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

 

 

'''The Library Function:'''

 

The following is the library implementation of the reverse function.

reverse(list(1))[i] :=

let

range := - ((1 ... size(list)) - (size(list) + 1));

in

 

=={{header|Sidef}}==

 

=={{header|Simula}}==

BEGIN

TEXT PROCEDURE REV(S); TEXT S;

OUTTEXT(REV(INP)); OUTIMAGE;

END

{{out}}

<pre>

=={{header|Slate}}==

In-place reversal:

Non-destructive reversal:

 

=={{header|Smalltalk}}==

{{works with|Smalltalk/X}}

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

which returns a new string.

 

=={{header|SNOBOL4}}==

ASCII-only

{{out}}

<pre>reverse</pre>

 

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

val string = "asdf";

 

=={{header|Stata}}==

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

 

. di strreverse(s)

SIVERB ATIV AGNOL SRA

. scalar s="Ἐν ἀρχῇ ἐποίησεν ὁ θεὸς τὸν οὐρανὸν καὶ τὴν γῆν"

. di ustrreverse(s)

 

=={{header|Swift}}==

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

{{works with|Swift|2.x+}}

return String(s.characters.reverse())

}

print(reverseString("asdf"))

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

return String(reverse(s))

}

println(reverseString("asdf"))

{{out}}

<pre>

 

=={{header|Symsyn}}==

| reverse string

 

endif

c []

OR

 

c : 'abcdefghijklmnopqrstuvwxyz'

 

endif

$s []

 

{{out}}

 

=={{header|Tailspin}}==

templates reverse

'$:[ $... ] -> $(last..first:-1)...;' !

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

{{out}}

<pre>

 

=={{header|Tcl}}==

 

=={{header|TI-83 BASIC}}==

Note: length( and sub( can be found in the catalog.

:For(I,1,length(Ans)-1

:sub(Ans,2I,1)+Ans

:End

 

=={{header|TMG}}==

Unix TMG:

str: smark any(!<<>>) scopy str/done = { 1 2 };

 

=={{header|Tosh}}==

ask "Say something..." and wait

set i to (length of answer)

change i by -1

end

 

=={{header|Turing}}==

Iterative solution, for character shovelers:

 

var rs := ""

for i : 0 .. length (s) - 1

 

put reverse ("iterative example")

 

{{out}}

Recursive solution, more natural in Turing:

 

if s = "" then

result s

 

put reverse ("recursive example")

 

{{out}}

 

=={{header|TUSCRIPT}}==

SET input="was it really a big fat cat i saw"

SET reversetext=TURN (input)

PRINT "before: ",input

{{out}}

<pre>

 

=={{header|UNIX Shell}}==

#!/bin/bash

str=abcde

 

echo $rev

 

'''or'''

 

str='i43go1342iu 23iu4o 23iu14i324y 2i13'

rev <<< "$str"

#rev is not built-in function, though is in /usr/bin/rev

 

=={{header|Unlambda}}==

Reverse the whole input:

 

=={{header|Ursala}}==

 

#cast %s

example = ~&x 'asdf'

 

{{out}}

<pre>

 

=={{header|Vala}}==

if (args.length < 2) {

stdout.printf ("Please, input a string.\n");

stdout.printf ("%s\n", str.str.strip ().reverse ());

return 0;

 

=={{header|VBA}}==

===Non-recursive version===

' returns the reversed string

dim L as integer 'length of string

next

Reverse = newString

===Recursive version===

'returns the reversed string

'do it recursively: cut the string in two, reverse these fragments and put them back together in reverse order

RReverse = RReverse(Right$(aString, L - M)) & RReverse(Left$(aString, M))

End If

===Example dialogue===

<pre>

=={{header|VBScript}}==

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

WScript.Echo StrReverse("asdf")

 

=={{header|Vedit macro language}}==

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

for (BOL; !At_EOL; Char) {

Reg_Copy_Block(10, CP, CP+1, INSERT)

This routine reverses the current line in-place:

while (!At_EOL) {

Block_Copy(EOL_pos-1, EOL_pos, DELETE)

 

=={{header|Visual Basic}}==

{{works with|Visual Basic|6}}

 

=={{header|Visual Basic .NET}}==

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

 

 

Module Program

#End If

End Sub

 

{{out|note=copied from Notepad}}

 

=={{header|Wart}}==

 

Wart doesn't support Unicode yet.

 

=={{header|Wren}}==

{{libheader|Wren-str}}

{{libheader|Wren-upc}}

 

for (word in ["asdf", "josé", "møøse", "was it a car or a cat I saw", "😀🚂🦊"]) {

for (word in ["as⃝df̅", "ℵΑΩ 駱駝道 🤔 🇸🇧 🇺🇸 🇬🇧‍ 👨‍👩‍👧‍👦🆗🗺"]) {

System.print(Graphemes.new(word).toList[-1..0].join())

 

{{out}}

 

=={{header|Wortel}}==

@rev "abc" ; returns "cba"

; or the same thing using a pointer expression

 

=={{header|XBS}}==

Using the standard library

{{out}}

<pre>

</pre>

Using [[JavaScript]] methods

{{out}}

<pre>

</pre>

Using a custom method

set Final = "";

for(i=?String-1;0;-1){

send Final;

}

{{out}}

<pre>

 

=={{header|XPL0}}==

string 0; \use zero-terminated strings, instead of MSb terminated

 

Text(0, RevStr("abc")); CrLf(0);

Text(0, RevStr("Able was I ere I saw Elba.")); CrLf(0);

 

Output:

=={{header|Yorick}}==

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

 

=={{header|Z80 Assembly}}==

This method uses the stack as a temporary store to reverse the order of characters in a string, and self-modifying code to restore the loop counter.

 

Terminator equ 0 ;null terminator for strings

 

djnz LOOP_REVERSESTRING_POP

pop de

 

{{out}}

 

=={{header|Zoea}}==

program: reverse_string

input: xyzzy

output: yzzyx

 

=={{header|Zoea Visual}}==

[http://zoea.co.uk/examples/zv-rc/Reverse_string.png Reverse string]