Palindrome detection: Difference between revisions

[[Category:String manipulation]]

[[Category:Classic CS problems and programs]]

 

A [[wp:Palindrome|palindrome]] is a phrase which reads the same backward and forward.

 

{{task heading|Related tasks}}

{{Related tasks/Word plays}}

 

 

=={{header|ACL2}}==

(if (zp i)

(mv xs ys)

(if (= (mod lngth 2) 1)

(equal (rest xs) ys)

 

=={{header|ActionScript}}==

The following function handles non-ASCII characters properly, since charAt() returns a single Unicode character.

{

for(var first:uint = 0, second:uint = str.length - 1; first < second; first++, second--)

if(str.charAt(first) != str.charAt(second)) return false;

return true;

=={{header|Ada}}==

begin

for Offset in 0..Text'Length / 2 - 1 loop

end loop;

return True;

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

{{trans|C}}

{{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 - except for the '''FORMAT''' and ''printf'' in test}}

PROC palindrome = (STRING s)BOOL:(

FOR i TO UPB s OVER 2 DO

printf((template, t, palindrome(t)));

printf((template, t, palindrome r(t)))

{{out}}

<pre>

</pre>

 

 

=={{header|AppleScript}}==

 

Using post-Yosemite AppleScript (to pull in lowercaseStringWithLocale from Foundation classes)

 

 

-- isPalindrome :: String -> Bool

end isPalindrome

 

 

 

on run

--> true

end run

 

 

 

-- filter :: (a -> Bool) -> [a] -> [a]

repeat with i from 1 to lng

set v to item i of xs

end repeat

return lst

end tell

end filter

 

-- Lift 2nd class handler function into 1st class script wrapper

else

script

end script

end if

 

=={{header|Applesoft BASIC}}==

110 DATA"MADAM, I'M ADAM."

120 DATA"1 ON 1"

350 PA = MID$(W$, L0, 1) = MID$(W$, L - L0 + 1, 1)

360 IF PALINDROME THEN NEXT L0

 

=={{header|AutoHotkey}}==

Reversing the string:

Loop, Parse, Str

ReversedStr := A_LoopField . ReversedStr

return, (ReversedStr == Str)?"Exact":(RegExReplace(ReversedStr,"\W")=RegExReplace(Str,"\W"))?"Inexact":"False"

 

=={{header|AutoIt}}==

 

 

Global $aString[7] = [ _

Return True

EndFunc

{{out}}

"In girum imus nocte, et consumimur igni" is an inexact palindrome.

"Madam, I'm Adam." is an inexact palindrome.

"Ein Neger mit Gazelle zagt im Regen nie." is an inexact palindrome.

"something wrong" is not a palindrome.

 

--[[User:BugFix|BugFix]] ([[User talk:BugFix|talk]]) 14:26, 13 November 2013 (UTC)

See [[Reversing a string]].

 

{

if ( s == reverse(s) ) return 1

return 0

 

'''Recursive'''

 

{

if ( length(s) < 2 ) return 1

if ( substr(s, 1, 1) != substr(s, length(s), 1) ) return 0

return is_palindro_r(substr(s, 2, length(s)-2))

 

'''Testing'''

pal = "ingirumimusnocteetconsumimurigni"

print is_palindro(pal)

print is_palindro_r(pal)

 

=={{header|BASIC}}==

{{works with|QBasic}}

 

 

DIM txt$

RvrsText$ = NewText$

 

 

{{out}}

Is not a palindrome.

 

PRINT """" test$ """" ;

IF FNpalindrome(FNletters(test$)) THEN

ENDIF

NEXT

{{out}}

<pre>"A man, a plan, a canal: Panama!" is a palindrome</pre>

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

 

setlocal enabledelayedexpansion

set /p string=Your string :

echo %string% %palindrome% a palindrome.

pause

 

Or, recursive (and without setlocal enabledelayedexpansion) (compatible with ReactOS cmd.exe)

set /p testString=Your string (all same case please) :

call :isPalindrome result %testString: =%

call :isPalindrome %1 %string:~1,-1%

)

 

=={{header|Befunge}}==

 

The following code reads a line from stdin and prints "True" if it is a palindrome, or False" otherwise.

~->p5p ^ 0v1p80-1g80vj!-g5g80g5_0'ev

:a^80+1:g8<>8g1+:18pv>0"eslaF">:#,_@

 

{{works with|Befunge|93}}

* The potential palindrome can be no longer than 76 characters (which beats the previous version's 11), and ''everything'' (spaces, punctuation, capitalization, etc.) is considered part of the palindrome. (Best to just use lower case letters and ''nothing else''.)

 

2^ < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < <

4 ^_v ^_v ^_v ^_v ^_v ^_v ^_v ^_v ^_v ^_v ^_v ^_v

>09g8p09g1+09pv

|: < <

 

=={{header|Bracmat}}==

= a

. @(!arg:(%?a&utf$!a) ?arg !a)

)

&

Output:

<pre>In girum imus nocte et consumimur igni is indeed a palindrome

palindrome

</pre>

 

=={{header|Burlesque}}==

 

zz{ri}f[^^<-==

 

=={{header|C}}==

and if the length is odd, the middle doesn't need to be checked (so it's okay to do integer division by 2, which rounds down).

 

 

int palindrome(const char *s)

}

return 1;

More idiomatic version:

{

const char *t; /* t is a pointer that traverses backwards from the end */

}

return 1;

 

'''Recursive'''

itself a palindrome.

 

{

if ( (e - 1) <= b ) return 1;

if ( s[b] != s[e-1] ) return 0;

return palindrome_r(s, b+1, e-1);

 

'''Testing'''

 

#include <string.h>

/* testing */

t, palindrome_r(t, 0, l) ? "" : "n't");

return 0;

 

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

'''Non-recursive'''

 

 

class Program

Console.WriteLine(IsPalindrome("ingirumimusnocteetconsumimurigni"));

}

 

'''Using LINQ operators'''

using System.Linq;

 

}

}

 

'''No string reversal'''

 

Reversing a string is very slow. A much faster way is to simply compare characters.

 

static class Program

Console.WriteLine("ingirumimusnocteetconsumimurigni".IsPalindrome());

}

 

=={{header|Clojure}}==

 

 

'''Test'''

false

</pre>

 

=={{header|COBOL}}==

{{works with|GnuCOBOL}}

function-id. palindromic-test.

 

goback.

end function palindromic-test.

 

=={{header|CoffeeScript}}==

String::isPalindrome = ->

for i in [0...@length / 2] when @[i] isnt @[@length - (i + 1)]

'There is no spoon.'

]

 

{{out}}

 

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

 

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

BlackBox Component Builder

MODULE BbtPalindrome;

IMPORT StdLog;

END Do;

END BbtPalindrome.

Execute: ^Q BbtPalindrome.Do<br/>

{{out}}

</pre>

 

 

 

=={{header|D}}==

===High-level 32-bit Unicode Version===

 

bool isPalindrome1(C)(in C[] s) pure /*nothrow*/

assert(pali("ingirumimusnocteetconsumimurigni"));

assert(pali("salàlas"));

 

===Mid-level 32-bit Unicode Version===

 

bool isPalindrome2(C)(in C[] s) pure if (isSomeChar!C) {

assert(pali("ingirumimusnocteetconsumimurigni"));

assert(pali("salàlas"));

 

===Low-level 32-bit Unicode Version===

 

// assume alloca() to be pure for this program

assert(pali("ingirumimusnocteetconsumimurigni"));

assert(pali("salàlas"));

 

===Low-level ASCII Version===

if (str.length == 0) return true;

immutable(char)* s = str.ptr;

assert(pali("ingirumimusnocteetconsumimurigni"));

//assert(pali("salàlas"));

 

=={{header|Dart}}==

 

bool isPalindrome(String s){

for(int i = 0; i < s.length/2;i++){

return true;

}

 

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

 

local :seq chars

local :len-seq -- len seq

 

!. palindrome? "ingirumimusnocteetconsumimurigni"

{{out}}

<pre>true

The for loop syntax is <code>for <var>key pattern</var> => <var>value pattern</var> in <var>collection</var> { ... }</code>, <code>?</code> imposes an additional boolean condition on a pattern (it may be read “''such that''”), and if the pattern does not match in a for loop then the iteration is skipped, so false is returned only if <code>upper[last - i] != c</code>.

 

def upper := string.toUpperCase()

def last := upper.size() - 1

}

return true

 

=={{header|EchoLisp}}==

;; returns #t or #f

(define (palindrome? string)

;;(let ((string (string-replace string "/\ /" "" "g")))

;;(equal? (string->list string) (reverse (string->list string)))))

 

=={{header|Eiffel}}==

is_palindrome (a_string: STRING): BOOLEAN

-- Is `a_string' a palindrome?

end

end

 

=={{header|Ela}}==

 

 

isPalindrome xs = xs == reverse xs

isPalindrome <| toList "ingirumimusnocteetconsumimurigni"

 

Function <code>reverse</code> is taken from list module and is defined as:

 

 

foldl f z (x::xs) = foldl f (f z x) xs

foldl _ z [] = z

 

=={{header|Elixir}}==

defmodule PalindromeDetection do

def is_palindrome(str), do: str == String.reverse(str)

end

Note: Because of Elixir's strong Unicode support, this even supports graphemes:

<pre>

true

</pre>

=={{header|Elm}}==

import Html exposing (Html, Attribute, text, div, input)

import Html.Attributes exposing (placeholder, value, style)

, ("font-size", "1em")

, ("text-align", "left")

 

Link to live demo: http://dc25.github.io/palindromeDetectionElm/

 

=={{header|Erlang}}==

-module( palindrome ).

 

 

display( String1, String2 ) -> io:fwrite( "Is ~p a palindrom? ~p~n", [String1, is_palindrome(String2)] ).

{{out}}

<pre>

 

=={{header|Euphoria}}==

for i = 1 to length(s)/2 do

if s[i] != s[$-i+1] then

end for

return 1

 

=={{header|F Sharp|F#}}==

let arr = s.ToCharArray()

 

Examples:

val it : bool = true

isPalindrome ("In girum imus nocte et consumimur igni".Replace(" ", "").ToLower());;

val it : bool = true

isPalindrome "abcdef"

 

=={{header|Factor}}==

 

=={{header|Fantom}}==

 

class Palindrome

{

}

}

 

=={{header|FBSL}}==

 

 

FUNCTION stripNonAlpha(BYVAL s AS STRING) AS STRING

 

PAUSE

{{out}}

<pre>

 

=={{header|Forth}}==

: last >r 2dup + 1- c@ r> swap ;

: palindrome? ( c-addr u -- f )

1 /string 1-

again ;

 

FIRST and LAST are once-off words that could be beheaded immediately afterwards.

The horizontal formatting highlights the parallel code - and potential factor;

a library of many string tests like this could have ?SUCCESS and ?FAIL .

 

=={{header|Fortran}}==

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

 

implicit none

print *, is_palindro("last test")

 

 

'''Non-recursive'''

 

function is_palindro(t)

logical :: is_palindro

forall(i=1:len(t)) s(len(t)-i+1:len(t)-i+1) = t(i:i)

isp = ( s == t )

 

'''Recursive'''

 

implicit none

isp = len (t) == 0 .or. t (: 1) == t (len (t) :) .and. is_palindro_r (t (2 : len (t) - 1))

 

 

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console "filename".bas

 

Print : Print : Print "Hit any key to end program"

Sleep

{{out}}

<pre> reverse(test) = FALSE

 

=={{header|Frink}}==

 

 

Test in Frink with upper-plane Unicode:

 

<code>

true

</code>

 

=={{header|GAP}}==

local upper, lower, c, i, n, t;

upper := "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

t := ZapGremlins(s);

return t = Reversed(t);

=={{header|GML}}==

//Setting a var from an argument passed to the script

var str;

//returns true if the sequence is a palindrome else returns false

return (str == inv);

 

Palindrome detection using a [http://rosettacode.org/wiki/Loop/Downward_For#GML Downward For-Loop]

 

 

//Remove everything except for letters and digits and convert the string to lowercase. source is what will be compared to str.

//Return if it is a palindrome.

return source == str;

 

=={{header|Go}}==

 

func IsPal(s string) bool {

}

return true

 

This version works with Unicode,

 

func isPalindrome(s string) bool {

runes := []rune(s)

}

return true

 

Or using more slicing,

 

func isPalindrome(s string) bool {

runes := []rune(s)

}

return true

 

=={{header|Groovy}}==

 

Solution:

s == s?.reverse()

 

Test program:

println isPalindrome("a")

println isPalindrome("abcdefgfedcba")

println isPalindrome("abcdeffedcba")

 

{{out}}

 

Solution:

def n = s.size()

n < 2 || s[0..<n/2] == s[-1..(-n/2)]

 

Test program and output are the same.

 

Solution follows the [[#C|C palindrome_r]] recursive solution:

isPalindrome = { String s ->

def n = s.size()

n < 2 || (s[0] == s[n-1] && isPalindrome(s[1..<(n-1)]))

 

Test program and output are the same.

A string is a palindrome if reversing it we obtain the same string.

 

 

'''Recursive'''

 

 

| head x == last x = is_palindrome_r . tail. init $ x

 

=={{header|HicEst}}==

{{incorrect|HicEst|The stripping of spaces and case conversion should be outside the palindrome detection.}}

 

END

 

IF( Palindrome == 0 ) RETURN

ENDDO

 

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

every writes(s := !arglist) do write( if palindrome(s) then " is " else " is not", " a palindrome.")

 

The following simple procedure uses the built-in reverse. Reverse creates a transient string which will get garbage collected.

return s == reverse(s)

{{libheader|Icon Programming Library}}

 

 

This version uses positive and negative sub-scripting and works not only on strings but lists of strings, such as ["ab","ab"] or ["ab","x"] the first list would pass the test but the second wouldn't.

local i

every if x[i := 1 to (*x+ 1)/2] ~== x[-i] then fail

return x

 

=={{header|Ioke}}==

 

=={{header|J}}==

 

Reverse and match method

Example usage

1

isPalin0 -.&' ' tolower 'In girum imus nocte et consumimur igni'

 

'''Recursive'''

 

Tacit and explicit verbs:

 

isPalin2=: monad define

if. 1>:#y do. 1 return. end.

if. ({.={:)y do. isPalin2 }.}:y else. 0 end.

 

Note that while these recursive verbs are bulkier and more complicated, they are also several thousand times more inefficient than isPalin0.

 

ts=:6!:2,7!:2 NB. time and space required to execute sentence

ts 'isPalin0 foo'

1599.09 1164.23

'isPalin2 foo' %&ts 'isPalin0 foo'

 

=={{header|Java}}==

'''Non-Recursive'''

 

StringBuilder sb = new StringBuilder(testMe);

return testMe.equals(sb.reverse().toString());

'''Recursive (this version does not work correctly with upper-plane Unicode)'''

 

if(testMe.length()<=1){

return true;

}

return rPali(testMe.substring(1, testMe.length()-1));

 

'''Recursive using indexes (this version does not work correctly with upper-plane Unicode)'''

 

int strLen = testMe.length();

return rPaliHelp(testMe, strLen-1, strLen/2, 0);

return rPaliHelp(testMe, strLen, testLen, index + 1);

}

 

'''Regular Expression'''

([http://stackoverflow.com/questions/3664881/how-does-this-java-regex-detect-palindromes source])

return testMe.matches("|(?:(.)(?<=(?=^.*?(\\1\\2?)$).*))+(?<=(?=^\\2$).*)");

 

=={{header|JavaScript}}==

return str === str.split("").reverse().join("");

}

 

 

ES6 implementation

 

 

 

// isPalindrome :: String -> Bool

 

 

 

 

 

 

{{Out}}

<pre>true</pre>

 

=={{header|jq}}==

'''Example''':

"salàlas" | palindrome

{{Out}}

true

 

=={{header|Julia}}==

<b> Non-Recursive </b>

function palindrome(s)

len = length(s)

return true

end

<b> Recursive </b>

function palindrome(s)

len = length(s)

end

return false

 

=={{header|k}}==

 

=={{header|LabVIEW}}==

{{VI solution|LabVIEW_Palindrome_detection.png}}

 

 

=={{header|Lasso}}==

 

local(_text = string(#text)) // need to make copy to get rid of reference issues

ispalindrome('Hello World')

 

{{out}}

<pre>true

 

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

print isPalindrome(removePunctuation$("In girum imus nocte et consumimur igni", "S"))

print isPalindrome(removePunctuation$("In girum imus nocte et consumimur igni", "SC"))

next i

removePunctuation$ = string$

 

{{out}}

 

=={{header|LiveCode}}==

if exact is empty or exact is not false then

set caseSensitive to true --default is false

end repeat

return revstr

 

=={{header|Logo}}==

output equal? :w reverse :w

 

=={{header|Lua}}==

 

=={{header|M4}}==

'''Non-recursive'''

This uses the <code>invert</code> from [[Reversing a string]].

palindrorev(`ingirumimusnocteetconsumimurigni')

 

'''Recursive'''

define(`cmplast',`ifelse(`striptwo(`$1')',,`yes',dnl

substr(`$1',0,1),substr(`$1',eval(len(`$1')-1),1),`yes',`no')')dnl

ifelse(eval(len(`$1')<1),1,`yes',cmplast(`$1'),`yes',`palindro(striptwo(`$1'))',`no')')dnl

palindro(`ingirumimusnocteetconsumimurigni')

 

 

=={{header|Maple}}==

This uses functions from Maple's built-in <code>StringTools</code> package.

 

with(StringTools):

 

 

IsPalindrome(LowerCase(DeleteSpace("In girum imus nocte et consumimur igni")));

 

{{out}}

</pre>

 

{{out|Examples}}

<pre>PalindromeQ["TNT"]

PalindromeQ["test"]

{{out}}

<pre>True

False

True

True

 

=={{header|MATLAB}}==

trueFalse = all(string == fliplr(string)); %See if flipping the string produces the original string

end

 

{{out|Sample Usage}}

 

ans =

 

1

 

=={{header|Maxima}}==

 

 

=={{header|MAXScript}}==

'''Non-recursive'''

 

(

local reversed = ""

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

return reversed == s

 

'''Recursive'''

 

(

if s.count <= 1 then

isPalindrome_r (substring s 2 (s.count-2))

)

 

'''Testing'''

 

format ("'%' is a palindrome? %\n") p (isPalindrome p)

 

=={{header|Mirah}}==

StringBuilder.new(s).reverse.toString()

end

puts palindrome?("Erik") # ==> false

puts palindrome?("palindroom-moordnilap") # ==> true

 

=={{header|ML}}==

==={{header|mLite}}===

 

fun only_alpha s = implode ` filter (fn x = c_alphabetic x) ` explode s

println ` test (is_palin, "Lagerregal", true, "is a palindrome", "is NOT a palindrome");

println ` test (is_palin, "Ein Neger mit Gazelle zagt im Regen nie.", true, "is a palindrome", "is NOT a palindrome");

Output:

<pre>'In girum imus nocte, et consumimur igni' is a palindrome

 

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

fun palindrome s =

let val cs = explode s in

cs = rev cs

end

 

=={{header|MMIX}}==

argv IS $1

 

1H TRAP 0,Fputs,StdOut % print

3H XOR $255,$255,$255

 

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

 

IMPORT Text;

RETURN TRUE;

END isPalindrome;

 

=={{header|Nemerle}}==

using System.Console;

using Nemerle.Utility.NString; //contains methods Explode() and Implode() which convert string -> list[char] and back

WriteLine("radar is a palindrome: {0}", IsPalindrome("radar"));

}

And a function to remove spaces and punctuation and convert to lowercase

{

def sepchars = Explode(",.;:-?!()' ");

Concat( "", Split(text, sepchars)).ToLower()

 

=={{header|NetRexx}}==

{{Trans|REXX}}

y='In girum imus nocte et consumimur igni'

 

/* and translate to uppercase. */

return x==x.reverse() /* returns 1 if exactly equal */

 

=={{header|NewLISP}}==

Works likewise for strings and for lists

(define (palindrome? s)

(setq r s)

(define (palindrome? s)

(= s (reverse (copy s))))

 

=={{header|Nim}}==

 

 

 

=={{header|Objeck}}==

bundle Default {

class Test {

}

}

 

=={{header|OCaml}}==

 

let l = String.length s in

let rec comp n =

n = 0 || (s.[l-n] = s.[n-1] && comp (n-1)) in

 

and here a function to remove the white spaces in the string:

 

let len = String.length str in

let rec aux i j =

if i >= len

else match str.[i] with

aux (i+1) (j)

aux (i+1) (j+1)

in

 

 

=={{header|Octave}}==

'''Recursive'''

if ( length(s) == 1 )

v = true;

v = false;

endif

 

'''Non-recursive'''

v = all( (s == s(length(s):-1:1)) == 1);

 

'''Testing'''

 

=={{header|Oz}}==

{Reverse S} == S

 

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

s=Vec(s);

for(i=1,#v\2,

);

1

 

A version for numbers:

{{works with|PARI/GP|2.6.0 and above}}

my(d=digits(n));

for(i=1,#d\2,

);

1

 

=={{header|Pascal}}==

{{works with|Free Pascal}}

 

{ RECURSIVE }

else

is_palindro := false

 

begin

write('"', s, '" is ');

test_r(s1, is_palindro(s1));

test_r(s2, is_palindro(s2))

 

=={{header|Perl}}==

before you call these functions.

 

package Palindrome;

 

{

(@_ ? shift : $_) =~ /^(.?|(.)(?1)\2)$/ + 0

 

This example shows how to use the functions:

 

use strict;

use warnings;

palindrome_r => sub { palindrome_r $latin },

palindrome_e => sub { palindrome_e $latin },

 

{{out}} on a machine running Perl 5.10.1 on amd64-openbsd:

The Perl regular expression engine recursed twice as fast as the Perl interpreter.

 

{{out}}

 

 

=={{header|PHP}}==

function is_palindrome($string) {

return $string == strrev($string);

}

 

Regular expression-based solution ([http://www.polygenelubricants.com/2010/09/matching-palindromes-in-pcre-regex.html source])

function is_palindrome($string) {

return preg_match('/^(?:(.)(?=.*(\1(?(2)\2|))$))*.?\2?$/', $string);

}

 

=={{header|PicoLisp}}==

{{out}}

<pre>: (palindrome? "ingirumimusnocteetconsumimurigni")

 

=={{header|Pike}}==

if(pal("rotator")){

write("palindrome!\n");

return 0;

}

 

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

To satisfy the revised specification (which contradicts the preceding explanation)

the following trivially solves the problem in PL/I:

 

The following solution strips spaces:

declare text character (*) varying;

 

return (substr(text, 1, j));

end remove_blanks;

 

=={{header|Potion}}==

palindrome_i = (s, b, e):

if (e <= b): true.

palindrome_i(s, 0, s length - 1).

 

 

=={{header|PowerBASIC}}==

The output is identical to the [[#BASIC|QBasic]] version, above.

 

DIM whatcopy AS STRING, chk AS STRING, tmp AS STRING * 1, L0 AS LONG

 

END IF

NEXT

 

=={{header|PowerShell}}==

Function Test-Palindrome( [String] $Text ){

$CharArray = $Text.ToCharArray()

[Array]::Reverse($CharArray)

}

===PowerShell (Regex Version)===

function Test-Palindrome

{

$Text -match "^(?'char'[a-z])+[a-z]?(?:\k'char'(?'-char'))+(?(char)(?!))$"

}

Test-Palindrome -Text 'radar'

{{Out}}

<pre>

True

</pre>

Test-Palindrome -Text "In girum imus nocte et consumimur igni."

{{Out}}

<pre>

False

</pre>

Test-Palindrome -Text "In girum imus nocte et consumimur igni." -Inexact

{{Out}}

<pre>

True

</pre>

 

From [http://www2.dcs.hull.ac.uk/NEAT/dnd/AI/prolog/tutorial2.html this tutorial].

 

 

'''Recursive'''

 

{{works with|SWI Prolog}}

 

Changing '''string''' into '''atom''' makes the program run also on GNU Prolog. I.e.

{{works with|GNU Prolog}}

 

=={{header|PureBasic}}==

{{works with|PureBasic|4.41}}

If StringToTest=ReverseString(StringToTest)

ProcedureReturn 1

ProcedureReturn 0

EndIf

 

=={{header|Python}}==

but right syntax <tt>string[::-1]</tt>)

 

 

'''Recursive'''

 

if len(s) <= 1:

return True

return False

else:

 

Python has short-circuit evaluation of Boolean operations

so a shorter and still easy to understand recursive function is

 

 

'''Testing'''

 

assert all(f(x) for x in good)

assert not any(f(x) for x in bad)

notpals = ('aA', 'abA', 'abxBa', 'abxxBa')

for ispal in is_palindrome, is_palindrome_r, is_palindrome_r2:

 

''' Palindrome Using Regular Expressions Python 2.7 '''

 

import re, string

re1="" # Beginning of Regex

else:

print("Nope!")

 

=={{header|R}}==

R will assume an infinite recursion if a recursion nests deeper than 5,000.

Options may be set in the environment to increase this to 500,000.

if ( nchar(p) == 1 ) {

return(TRUE)

}

}

 

'''Iterative'''

for(i in 1:floor(nchar(p)/2) ) {

r <- nchar(p) - i + 1

}

TRUE

 

'''Comparative'''

Note that this method incorrectly regards an empty string as not a palindrome.

Please leave this bug in the code, and take a look a the [[Testing_a_Function]] page.

return(

paste(

)

}

 

{{out}}

<pre>

test <- "ingirumimusnocteetconsumimurigni"

=={{header|Racket}}==

 

(define (palindromb str)

(let* ([lst (string->list (string-downcase str))]

#t

>

 

=={{header|Rascal}}==

The most simple solution:

 

 

A solution that handles sentences with spaces and capitals:

 

 

public bool palindrome(str text){

return text == reverse(text);

}

 

Example:

 

=={{header|REBOL}}==

 

Title: "Palindrome Recognizer"

URL: http://rosettacode.org/wiki/Palindrome

]

assert [palindrome? "In girum imus nocte et consumimur igni"] ; Spaces not removed.

 

 

{{out}}

=={{header|Retro}}==

 

 

 

=={{header|REXX}}==

===version 1===

parse arg y /*get (optional) phrase from the C.L. */

if y='' then y='In girum imus nocte et consumimur igni' /*[↓] translation.*/

/*────────────────────────────────────────────────────────────────────────────*/

isTpal: return reverse(arg(1))==arg(1)

<pre>

string = In girum imus nocte et consumimur igni

</pre>

 

{{works with|ARexx}}

It should be noted that the &nbsp; '''COMPRESS''' &nbsp; function is not a Classic REXX BIF and isn't present in many REXXes.

<br>The &nbsp; '''SPACE(string,0)''' &nbsp; BIF can be used instead.

It should also be noted that &nbsp; '''UPPER''' &nbsp; BIF is not present in some REXXes.

<br>Use the &nbsp; '''PARSE UPPER''' &nbsp; statement or &nbsp; '''TRANSLATE()''' &nbsp; BIF instead.

/*Check whether a string is a palindrome */

parse pull string

parse arg string

return string==reverse(string)

{{out}}

<pre>

 

=={{header|Ring}}==

aString = "radar"

bString = ""

if aString = bString see " is a palindrome." + nl

else see " is not a palindrome" + nl ok