Rot-13: Difference between revisions

 

 

 

=={{header|6502 Assembly}}==

Written for the BeebAsm assembler, which uses '&' to indicate a hexadecimal number. Call with the address of a zero terminated string in X and Y.

 

 

.rot13

 

=={{header|Ada}}==

with Ada.Strings.Maps; use Ada.Strings.Maps;

with Ada.Command_Line; use Ada.Command_Line;

end loop;

end if;

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

{{trans|Modula-3}}

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

<!-- {{does not work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386 - this release is missing on line end}} -->

CHAR c;

on logical file end(stand in, (REF FILE f)BOOL: (stop; SKIP));

print(c)

OD

Sample run on linux:

<pre>

Ovt swbeqf irk dhvpx jnygm alzcu!

</pre>

=={{header|AutoHotkey}}==

Code modified from [http://www.autohotkey.com/forum/viewtopic.php?t=8421 stringmod] by [http://www.autohotkey.com/forum/author-HugoV.html Hugo]: [http://www.autohotkey.com/forum/viewtopic.php?t=44657&postdays=0&postorder=asc&start=45 ahk discussion]

Str1 := Rot13(Str0)

Str2 := Rot13(Str1)

}

Return rStr

 

=={{header|AWK}}==

for(i=0; i < 256; i++) {

amap[sprintf("%c", i)] = i

}

print o

 

=={{header|BASIC}}==

{{works with|QBasic}}

INPUT "Enter a string: ", s$

ans$ = ""

ans$ = ans$ + char$

NEXT a

 

=={{header|Befunge}}==

:"Z"`#v_:"M"`#v_:"@"`|>

: 0 `#v_@v-6-7< >

 

=={{header|C}}==

 

 

 

}

 

{

}

 

int main(int argc, char *argv[])

{

 

 

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

using System.IO;

using System.Linq;

using System.Text;

 

 

}

 

 

Console.WriteLine(Rot13(File.ReadAllText(file)));

}

Console.WriteLine(Rot13(Console.In.ReadToEnd()));

}

}

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

#include <istream>

#include <ostream>

}

return EXIT_SUCCESS;

=={{header|Clojure}}==

 

 

 

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

The standard gives implementations great leeway with respect to character encodings, so we can't rely on the convenient properties of ASCII.

'(#\A #\B #\C #\D #\E #\F #\G #\H #\I #\J #\K #\L #\M #\N #\O #\P

#\Q #\R #\S #\T #\U #\V #\W #\X #\Y #\Z))

(nth (mod (+ 13 n) 26) +alphabet+))

c))

 

=={{header|D}}==

 

 

void main() {

<pre>The Quick Brown Fox Jumps Over The Lazy Dog!</pre>

void main() {

 

=={{header|E}}==

 

var rot13Map := [].asMap()

def rot13(s :String) {

return accum "" for c in s { _ + rot13Map.fetch(c, fn{ c }) }

 

=={{header|Erlang}}==

 

F = fun(C) when (C >= $A andalso C =< $M); (C >= $a andalso C =< $m) -> C + 13;

(C) when (C >= $N andalso C =< $Z); (C >= $n andalso C =< $z) -> C - 13;

(C) -> C

end,

 

=={{header|Euphoria}}==

{{works with|Euphoria|4.0.0}}

include std/types.e

include std/text.e

 

puts( 1, Rot13( "abjurer NOWHERE." ) & "\n" )

 

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

Illustrates turning a string into an array of chars then composition of type casting with a conversion function. We create a composite that converts its input to an integer, calls the convertion function and

then casts to a char type. The result is an array of modified chars that we can use to create a new string.

let rot c =

match c with

s |> Array.of_seq

|> Array.map(int >> rot >> char)

 

=={{header|FALSE}}==

 

=={{header|Fantom}}==

 

class Rot13

{

}

}

 

=={{header|Forth}}==

 

A simple version, using nested conditionals.

dup 32 or \ tolower

dup [char] a [char] z 1+ within if

[char] m > if -13 else 13 then +

 

A table driven version which should be more efficient. The mechanism is flexible enough to express any sort of transform.

do i c, loop ;

 

[char] " parse 2dup rot13-string type ;

 

=={{header|Fortran}}==

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

 

implicit none

end function rot_13

 

Note: <code>iargc</code> and <code>getarg</code> are common extensions that are implemented by e.g. the Intel Fortran Compiler, G95 and gfortran.

 

Sample usage:

foo

> cat bar.txt

> cat foo.txt bar.txt | ./rot_13

sbb

=={{header|GAP}}==

local upper, lower, c, n, t;

upper := "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

# "Ratynaq rkcrpgf gung rirel zna jvyy qb uvf qhgl"

c := rot13(b);

 

=={{header|Gema}}==

 

=={{header|GML}}==

 

}

}

 

The above code is called like this:

 

Output (in a message box):

 

=={{header|Go}}==

 

}

 

func rot13(s string) string {

 

=={{header|Groovy}}==

Solution:

(s as List).collect { ch ->

switch (ch) {

}

}.inject ("") { string, ch -> string += ch}

 

Test program:

 

Output:

<pre>Able was I, 'ere I saw Elba.</pre>

 

=={{header|Haskell}}==

Straightforward implementation by checking multiple cases:

 

 

rot13 :: Char -> Char

rot13 c

 

import System.IO

import System.Directory

process :: (Handle -> Handle -> IO ()) -> [String] -> IO ()

process f [] = f stdin stdout

 

Then the wrapped program is simply

names <- getArgs

 

Note that the framework will read the file lazily, which also provides buffering.

 

=={{header|HicEst}}==

 

DO i = 1, LEN_TRIM(txt)

 

WRITE(ClipBoard, Name) txt, cod ! txt=abc? XYZ!; cod=nop? KLM!;

 

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

file := open(arglist[1],"r") | &input

every write(rot13(|read(file)))

}

return map(s,a,n)

This example uses a number of Icon features.

* alternation ( x | y ) selects and opens a file if supplied or fall back to standard output

* the setup exploits the ordered cset variables &lcase and &ucase coercing them into strings

* the rot13 mapping string is then aggregated with strings taken by offsetting into double length values to avoid unnecessary and messy rotation

 

=={{header|J}}==

 

For example:

 

Compare with the solution to the [[Change_string_case#J|Change String Case]] task.

 

=={{header|Java}}==

=={{header|JavaScript}}==

rot13("ABJURER nowhere") // NOWHERE abjurer

 

=={{header|Logo}}==

make "a difference ascii lowercase :c ascii "a

if or :a < 0 :a > 25 [output :c]

 

print map "rot13 "|abjurer NOWHERE|

=={{header|Lua}}==

 

 

=={{header|MATLAB}}==

if ischar(s)

r=s; % preallocation and copy of non-letters

error('Argument must be a CHAR')

end

Call it like this:

 

ans =