Palindrome detection: Difference between revisions

{{trans|Python}}

 

 

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

PALINDRO CSECT

USING PALINDRO,R13 base register

MSG DC CL23'IT IS A TRUE PALINDROME'

YREGS

{{out}}

<pre>

=={{header|8080 Assembly}}==

 

jmp demo

;;; Is the $-terminated string at DE a palindrome?

w2: db 'racecar$'

w3: db 'level$'

 

{{out}}

 

=={{header|8086 Assembly}}==

org 100h

section .text

.w3: db 'level$'

.w4: db 'redder$'

 

{{out}}

 

=={{header|ACL2}}==

(if (zp i)

(mv xs ys)

(if (= (mod lngth 2) 1)

(equal (rest xs) ys)

 

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

BYTE l,r

 

Test("This sentence is not a palindrome.")

Test("123 456 789 897 654 321")

{{out}}

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

=={{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;

 

----

Ada 2012 version:

function Palindrome (Text : String) return Boolean is

(for all i in Text'Range => Text(i)= Text(Text'Last-i+Text'First));

 

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

=={{header|APL}}==

NARS2000 APL, dynamic function "if the argument matches the reverse of the argument", with Unicode character support:

0

{⍵≡⌽⍵} '⍋racecar⍋'

Or in tacit function form, a combination of three functions, right tack (echo), reverse, then the result of each compared with the middle one, match (equals):

0

(⊢≡⌽) 'nun'

An inexact version is harder, because uppercase and lowercase with Unicode awareness depends on APL interpreter; NARS2000 has no support for it. Classic case conversion means lookup up the letters in an alphabet of UppercaseLowercase, then mapping those positions into an UppercaseUppercase or LowercaseLowercase array. Remove non-A-Za-z first to get rid of punctuation, and get an inexact dynamic function with just English letter support:

inexact 'abc,-cbA2z'

0

inexact 'abc,-cbA2'

Dyalog APL has a Unicode-aware uppercase/lowercase function (819 I-beam), AFAIK no support for looking up Unicode character classes.

 

 

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

 

------ CASE-INSENSITIVE PALINDROME, IGNORING SPACES ? ----

((ca's NSString's stringWithString:(str))'s ¬

lowercaseStringWithLocale:(ca's NSLocale's currentLocale())) as text

{{Out}}

<pre>true</pre>

===Core language only===

It's not clear if "sequence of characters" means an array thereof or a single piece of text. But the basic method in AppleScript would be:

set txt to join(txt, "") -- In case the input's a list (array).

return (txt = join(reverse of txt's characters, ""))

end join

 

 

Text comparisons in AppleScript are case-insensitive by default, so:

 

{{output}}

 

If case is to be taken into account, the call to the handler can be enclosed in a 'considering case' control statement.

return isPalindrome("Radar")

 

{{output}}

 

It's also possible to "ignore" white space, hyphens, and punctuation, which are considered by default. And of course case can be ignored explicitly, if desired, to ensure that this condition's in force during the call to the handler. The attributes can be combined in one statement. So to check for inexact palindromicity (if that's a word):

 

return isPalindrome("Was it a 😀car, or a c😀at-I-saw?")

 

{{output}}

 

=={{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|ARM Assembly}}==

@ Returns with zero flag set if palindrome.

palin: mov r1,r0 @ Find end of string

w4: .asciz "redder"

w5: .asciz "rosetta"

 

{{out}}

 

=={{header|Arturo}}==

loop ["abba" "boom" "radar" "civic" "great"] 'wrd [

print [wrd ": palindrome?" palindrome? wrd]

 

{{out}}

=={{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|BaCon}}==

OPTION COMPARE TRUE

 

PRINT "Not a palindrome."

ENDIF

{{out}}

<pre>

 

=={{header|Bash}}==

#! /bin/bash

# very simple way to detect a palindrome in Bash

echo "$input is a palindrome"

fi

 

=={{header|BASIC}}==

{{works with|QBasic}}

 

 

DIM txt$

RvrsText$ = NewText$

 

 

{{out}}

 

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

100 PROGRAM "Palindr.bas"

110 LINE INPUT PROMPT "Text: ":TX$

280 IF TX$(I)<>TX$(LEN(TX$)-I+1) THEN LET PALIND=0:EXIT FOR

290 NEXT

 

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

====Exact palindrome====

The specification suggests, but does not insist, that we reverse the input string and then test for equality; this algorithm is more efficient.

20 FOR I=1 TO LEN S$/2

30 IF S$(I)<>S$(LEN S$-I+1) THEN GOTO 60

50 GOTO 70

60 PRINT "NOT A ";

====Inexact palindrome====

Add the following lines to convert the program into an inexact-palindrome checker (i.e. one that ignores non-alphabetic characters). The resulting program still works with only 1k of RAM. The ZX81 only supports its own character set, which does not include lower case, so that case-insensitive comparison and <i>a fortiori</i> Unicode are not possible.

80 STOP

90 LET T$=""

120 NEXT I

130 LET S$=T$

 

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

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|BCPL}}==

 

let palindrome(s) = valof

for i = 0 to 8 do

writef("'%S': %S*N", tests!i, check(tests!i))

{{out}}

<pre>'rotor': exact palindrome

 

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|BQN}}==

BQN considers characters as single units, and hence the functions support unicode by default.

 

Pal1 ← ⊢≡⌽

 

=={{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|C++}}==

The C solutions also work in C++, but C++ allows a simpler one:

#include <algorithm>

 

{

return std::equal(s.begin(), s.end(), s.rbegin());

 

Or, checking half is sufficient (on odd-length strings, this will ignore the middle element):

#include <algorithm>

 

{

return std::equal(s.begin(), s.begin()+s.length()/2, s.rbegin());

 

=={{header|Clojure}}==

 

'''lower-level, but somewhat faster'''

(loop [front 0 back (dec (.length s))]

(or (>= front back)

(and (= (.charAt s front) (.charAt s back))

 

'''Test'''

 

=={{header|CLU}}==

str_reverse = proc (s: string) returns (string)

chs: array[char] := array[char]$predict(0, string$size(s))

end

end

{{out}}

<pre>"rotor": exact palindrome

=={{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}}==

===Alternate solution===

I use [https://franz.com/downloads/clp/survey Allegro CL 10.1]

 

;; Project : Palindrome detection

 

(palindrome x)

(terpri)

Output:

<pre>

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

BlackBox Component Builder

MODULE BbtPalindrome;

IMPORT StdLog;

END Do;

END BbtPalindrome.

Execute: ^Q BbtPalindrome.Do<br/>

{{out}}

 

=={{header|Cowgol}}==

 

# Check if a string is a palindrome

end if;

i := i + 1;

 

{{out}}

=={{header|Crystal}}==

===Declarative===

def palindrome(s)

s == s.reverse

end

 

===Imperative===

def palindrome_imperative(s) : Bool

mid = s.size // 2

true

end

 

Also

 

mid = s.size // 2

mid.times { |j| return false if s[j] != s[-1 - j] }

true

 

Performance comparison

require "benchmark"

Benchmark.ips do |x|

x.report("imperative2") { palindrome_2("hannah")}

end

 

<pre>declarative 45.45M ( 22.00ns) (±11.16%) 32.0B/op fastest

=={{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|Delphi}}==

SysUtils, StrUtils;

 

begin

Result := SameText(aSrcString, ReverseString(aSrcString));

 

=={{header|Dyalect}}==

 

str == str.Reverse()

}

 

 

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

 

=={{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|Emacs Lisp}}==

 

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

 

include std/sequence.e -- reverse

include std/console.e -- display

s = remove_all(' ',upper(s))

display(iif(equal(s,reverse(s)),"true","false"))

{{out}}

<pre>

 

{{Works with| Office 265 Betas 2021}}

=LAMBDA(s,

LET(

CONCAT(lcs) = CONCAT(REVERSE(lcs))

)

 

and assuming that the following generic lambdas are also bound to the names CHARS, FILTERP, and REVERSE in the Name Manager for the active WorkBook:

 

=LAMBDA(s,

MID(s, ROW(INDIRECT("1:" & LEN(s))), 1)

)

)

{{Out}}

{| class="wikitable"

 

=={{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|Falcon}}==

'''VBA/Python programmer's approach not sure if it's the most falconic way'''

/* created by Aykayayciti Earl Lamont Montgomery

April 9th, 2018 */

a = "mom"

> is_palindrome(a)

{{out}}

<pre>

 

'''more falconic'''

/* created by Aykayayciti Earl Lamont Montgomery

April 9th, 2018 */

b = "mom"

> strUpper(b).replace(" ", "") == strUpper(b[-1:0]) ? "Is a palindrome" : "Is not a palindrome"

{{out}}

<pre>

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

'''Below is a separate Forth program that detects palindrome phrases as well as single word palindromes. It was programmed using gforth.'''

 

variable temp-addr

 

else ." << Not >> a Palindrome."

then cr ;

 

Example:

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

For example, the string "og\u0308o" represents an o, a g with combining diaeresis, followed by the letter o. Or, in other words, "og̈o". Note that while there are four Unicode codepoints, only three "graphemes" are displayed. Using Frink's smart "reverse" function preserves these combined graphemes and detects them correctly as palindromes.

 

 

Test in Frink with upper-plane Unicode:

 

<code>

true

</code>

 

=={{header|Fōrmulæ}}==

 

 

 

 

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

 

 

Or, applicative and point-free, with some pre-processing of data (shedding white space and upper case):

 

import Data.Char (toLower)

 

prepared cs = [toLower c | c <- cs, ' ' /= c]

 

{{Out}}

<pre>"" -> True

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

 

'''Non-Recursive using indexes (supports upper-plane Unicode)'''

for (int i = 0, j = input.length() - 1; i < j; i++, j--) {

char startChar = input.charAt(i);

}

return true;

 

'''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

 

Or, ignoring spaces and variations in case:

 

 

// isPalindrome :: String -> Bool

// MAIN ---

return main();

{{Out}}

<pre>true</pre>

 

=={{header|jq}}==

'''Example''':

"salàlas" | palindrome

 

=={{header|Jsish}}==

function isPalindrome(str:string, exact:boolean=true) {

if (!exact) {

isPalindrome('Never odd or even', false) ==> true

=!EXPECTEND!=

 

Most of that code is for testing, using echo mode lines (semicolon in column 1)

 

=={{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|Kotlin}}==

 

/* These functions deal automatically with Unicode as all strings are UTF-16 encoded in Kotlin */

println("'$candidate' is ${if (isInexactPalindrome(candidate)) "an" else "not an"} inexact palindrome")

}

 

{{out}}

 

=={{header|langur}}==

 

"": false,

"z": true,

val .foundpal = .ispal(.word)

writeln .word, ": ", .foundpal, if(.foundpal == .tests[.word]: ""; " (FAILED TEST)")

 

{{out}}

 

=={{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}}

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

Built-in function handling lists, numbers, and strings:

{{out|Examples}}

<pre>PalindromeQ["TNT"]

 

=={{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|min}}==

{{works with|min|0.19.3}}

(dup "" split reverse "" join ==) :str-palindrome?

 

"racecar" str-palindrome? puts

(a b c) palindrome? puts

{{out}}

<pre>

 

=={{header|MiniScript}}==

// convert to lowercase, and strip non-letters

stripped = ""

if not isPalindrome(testStr) then answer.push "NOT"

answer.push "a palindrome"

{{out}}

<pre>

 

=={{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-2}}==

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT WriteString,ReadChar;

 

ReadChar

 

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

 

IMPORT Text;

RETURN TRUE;

END isPalindrome;

 

=={{header|Nanoquery}}==

temp = ""

for char in s

 

return list(temp) = list(temp).reverse()

 

=={{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}}==

The following program detects if UTF-8 strings are exact palindromes. If "exact" is set to "false", it ignores the white spaces and the differences of letter case to detect inexact palindromes. Differences in punctuation are still relevant.

 

 

check "In girum imus nocte et consumimur igni"

check "Esope reste ici et se repose"

 

{{out}}

 

=={{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 res = Bytes.create len in

in

aux 0 0

 

and to make the test case insensitive, just use the function <tt>String.lowercase_ascii</tt>.

=={{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|Oforth}}==

 

 

=={{header|Ol}}==

; simple case - only lowercase letters

(define (palindrome? str)

(print (palindrome? "This is not a palindrome"))

; ==> #false

 

=={{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))

 

var

input, output: string;

else

writeln('input was not palindrome');

 

=={{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:

 

=={{header|Phix}}==

<span style="color: #008080;">function</span> <span style="color: #000000;">is_palindrome</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">return</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">==</span><span style="color: #7060A8;">reverse</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">extra_credit</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"가련하시다 사장집 아들딸들아 집장사 다시 하련가"</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">extra_credit</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"tregða, gón, reiði - er nóg að gert"</span><span style="color: #0000FF;">)</span>

 

=={{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|Picat}}==

Tests = ["In girum imus nocte et consumimur igni",

"this is a non palindrome string",

% skips punctuation and white space.

strip(S) = [C : C in S.to_lowercase(),

 

{{out}}

 

=={{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|PL/M}}==

 

/* CHECK EXACT PALINDROME ASSUMING $-TERMINATED STRING */

 

CALL BDOS(0,0);

{{out}}

<pre>ROTOR: EXACT

<code>first</code> is an address, while <code>first's target</code> is the byte at that address.

No need to actually reverse the string; just compare the first's target with the last's target until they meet in the middle.

Slap a substring on the string.

Loop.

Add 1 to the substring's first.

Subtract 1 from the substring's last.

 

=={{header|Pointless}}==

'''Basic Function'''

 

'''With Pre-processing'''

"A man, a plan, a canal -- Panama"

|> toList

|> map(toLower)

|> isPalindrome

 

{{out}}

 

=={{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}}==

An exact version based on reversing the string:

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

$CharArray = $Text.ToCharArray()

$Text -eq [string]::join('', $CharArray)

}

===PowerShell (Regex Version)===

This version is much faster because it does not manipulate arrays. [This is not clear; the above version was slowed down by using -join instead of [string]::join, and -like instead of -eq. After changing those it is similar, if not faster, than this 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>

===PowerShell (Unicode category aware, no string reverse)===

An inexact version can remove punctuation by looking at Unicode categories for each character, either using .Net methods or a regex.

[CmdletBinding()]

Param(

}

}

{{Out}}

<pre>

 

=={{header|Processing}}==

void setup(){

println(isPalindrome(InsertPalindromeHere));

}

}

 

{{out}}

 

====Alternative Implementation: using StringBuilder, implementing exact and inexact check====

void setup(){

println("PalindromeDetection");

return isExactPalindrome(s.replaceAll("\\s+","").replaceAll("[^A-Za-z]+", "").toLowerCase());

}

 

{{out}}

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

 

 

'''Non-recursive, Ignoring Punctuation/Case/Spaces'''

A word is a palindrome if the letters are the same forwards as backwards, but the other methods given here will return False for, e.g., an input of "Go hang a salami, I'm a lasagna hog" or "A man, a plan, a canal: Panama." An implementation that traverses the string and ignores case differences, spaces, and non-alpha characters is pretty trivial.

 

low = 0

high = len(s) - 1

low += 1

high -= 1

 

'''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!")

 

 

'''Checking the left half against a reflection of the right half'''

 

 

if __name__ == '__main__':

main()

{{out}}

<pre>'' -> True

-5 -4 -3 -2 -1 <-- negative index</pre>

 

for i in range(len(str)//2):

if str[i] != str[~i]:

return(False)

 

=={{header|Quackery}}==

 

 

[ [] swap witheach

dup lower = iff

drop else join ]

 

===Twiddle Indexing===

 

dup size 2 / times

[ dup i peek

over i ~ peek != if

[ dip not conclude ] ]

 

=={{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(

)

}

 

'''Rev'''

 

Unicode is supported, but this ignores the "inexact palindromes" extra credit requirement because, without some sort of regex, supporting Unicode while stripping punctuation and white space is hard in R.

{

characters <- unlist(strsplit(string, ""))

all(characters == rev(characters))

{{out}}

The rev solution is not benchmarked.

=={{header|Racket}}==

 

(define (palindromb str)

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

#t

>

 

=={{header|Raku}}==

(formerly Perl 6)

.flip eq $_ given .comb(/\w+/).join.lc

}

END

{{out}}

<pre>True A man, a plan, a canal: Panama.

=={{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}}==

 

:palindrome? (s-f) dup s:hash [ s:reverse s:hash ] dip eq? ;

 

'ingirumimusnocteetconsumimurigni palindrome? n:put

 

=={{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)

{{out|output|text=''':'''}}

<pre>

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.

/* REXX */

 

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

 

=={{header|Ruby}}==

 

'''Non-recursive'''

 

s == s.reverse

 

'''Recursive'''

 

if s.length <= 1

true

r_palindrome?(s[1..-2])

end

 

'''Testing'''

Note that the recursive method is ''much'' slower -- using the 2151 character palindrome by Dan Hoey [http://www2.vo.lu/homepages/phahn/anagrams/panama.htm here], we have:

puts palindrome?(str) # => true

puts r_palindrome?(str) # => true

b.report('iterative') {10000.times {palindrome?(str)}}

b.report('recursive') {10000.times {r_palindrome?(str)}}

 

{{out}}

iterative 0.062000 0.000000 0.062000 ( 0.055000)

recursive 16.516000 0.000000 16.516000 ( 16.562000)</pre>

 

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

for i = 1 to 4

read w$

print w$;" is ";isPalindrome$(w$);" Palindrome"

next

{{out}}

<pre>My dog has fleas is not Palindrome

 

=={{header|Rust}}==

let half_len = string.len() / 2;

string

"The quick brown fox"

);

{{out}}

<pre>

</pre>

The above soluion checks if the codepoints form a pallindrome, but it is perhaps more correct to consider if the graphemes form a pallindrome. This can be accomplished with an external library and a slight modification to <code>is_palindrome</code>.

use unicode_segmentation::UnicodeSegmentation;

fn is_palindrome(string: &str) -> bool {

string.graphemes(true).eq(string.graphemes(true).rev())

 

=={{header|SAS}}==

Description

The macro "palindro" has two parameters: string and ignorewhitespace.

string is the expression to be checked.

This macro was written in SAS 9.2. If you use a version before SAS 9.1.3,

the compress function options will not work.

Code

%MACRO palindro(string, ignorewhitespace);

DATA _NULL_;

RUN;

%MEND;

Example macro call and output

%palindro("a man, a plan, a canal: panama",y);

 

real time 0.00 seconds

cpu time 0.00 seconds

 

=={{header|Scala}}==

{{libheader|Scala}}

=== Non-recursive, robustified===

===Bonus: Detect and account for odd space and punctuation===

(s.size >= 2) && {

val p = s.replaceAll("[^\\p{L}]", "").toLowerCase

p == p.reverse

}

 

===Recursive===

 

def isPalindromeRec(s: String) = {

 

(s.size >= 2) && inner(s)

'''Testing'''

assert(!isPalindrome(""))

assert(!isPalindrome("z"))

assert(!isPalindromeRec("A man a plan a canal Panama."))

 

 

=={{header|Scheme}}==

'''Non-recursive'''

 

(let ((chars (string->list s)))

 

'''Recursive'''

(let loop ((i 0)

(j (- (string-length s) 1)))

> (palindrome? "This is not a palindrome")

#f

 

=={{header|Seed7}}==

result

var boolean: isPalindrome is TRUE;

end if;

end for;

 

For palindromes where spaces shuld be ignore use:

 

=={{header|SequenceL}}==

'''Using the Reverse Library Function'''

 

 

'''Version Using an Indexed Function'''

let

compares[i] := string[i] = string[size(string) - (i - 1)] foreach i within 1 ... (size(string) / 2);

in

 

=={{header|Sidef}}==

 

'''Built-in'''

 

'''Non-recursive'''

 

s == s.reverse

 

'''Recursive'''

 

if (s.len <= 1) {

true

}

false

}

else {

}

 

=={{header|Simula}}==

 

BOOLEAN PROCEDURE ISPALINDROME(T); TEXT T;

END;

 

{{out}}

<pre>

=={{header|Slate}}==

'''Non-Recursive'''

[

(s lexicographicallyCompare: s reversed) isZero

 

'''Recursive'''

Defined on Sequence since we are not using String-specific methods:

[

s isEmpty

ifTrue: [True]

ifFalse: [(s first = s last) /\ [(s sliceFrom: 1 to: s indexLast - 1) isPalindrome]]

 

'''Testing'''

 

=={{header|Smalltalk}}==

 

{{works with|Squeak}}

str := (aString select: [:chr| chr isAlphaNumeric]) collect: [:chr | chr asLowercase].

str = str reversed.

].

 

{{works with|GNU Smalltalk}}

palindro [ "Non-recursive"

^ self = (self reverse)

]

]

 

'''Testing'''

 

('hello' palindroR) printNl.

('ingirumimusnocteetconsumimurigni' palindro) printNl.

 

{{works with|VisualWorks Pharo Squeak}}

^self reverse = self

 

=={{header|SNOBOL4}}==

 

pal str notany(&ucase &lcase) = :s(pal)

str = replace(str,&ucase,&lcase)

palchk('In girum imus nocte et consumimur igni')

palchk('The quick brown fox jumped over the lazy dogs')

 

{{out}}

The quick brown fox jumped over the lazy dogs

Palindrome: False</pre>

 

=={{header|SQL}}==

 

=={{header|Swift}}==

{{works with|Swift|1.2}}

 

// Allow for easy character checking

}

return false

 

{{works with|Swift|2.0}}

let c = str.characters

return lazy(c).reverse()

.startsWith(c[c.startIndex...advance(c.startIndex, c.count / 2)])

 

=={{header|Tcl}}==

'''Non-recursive'''

 

proc palindrome {s} {

return [expr {$s eq [string reverse $s]}]

 

'''Recursive'''

 

if {[string length $s] <= 1} {

return true

return [palindrome_r [string range $s 1 end-1]]

}

 

'''Testing'''

 

puts "'$p' is palindrome? [palindrome $p]"

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

pal ="ingirumimusnocteetconsumimurigni"

PRINT/ERROR "untrue"

ENDSELECT

{{out}}

<pre>

 

=={{header|TypeScript}}==

 

function stripDiacritics(phrase:string){

console.log(isPalindrome('Dábale arroz a la zorra el abad!'))

console.log(isPalindrome('Я иду с мечем судия'))

 

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

echo "Palindrome"

else

echo "Not a palindrome"

 

=={{header|Ursala}}==

This is done using the built in operator suffixes

for intersection (c), identity (i), reversal (x) and equality (E).

 

This test programs applies the function to each member of a list of three strings,

of which only the first two are palindromes.

 

{{out}}

<pre><true,true,false></pre>

=={{header|Vala}}==

Checks if a word is a palindrome ignoring the case and spaces.

var tmp = str.casefold ().replace (" ", "");

return tmp == tmp.reverse ();

print (is_palindrome (args[1]).to_string () + "\n");

return 0;

 

=={{header|VBA}}==

version it could also work using StrReverse.

 

Public Function isPalindrome(aString as string) as Boolean

dim tempstring as string

isPalindrome = (tempstring = Reverse(tempstring))

End Function

 

{{out|Example}}

=={{header|VBScript}}==

====Implementation====

dim sRes

sRes = vbNullString

squished = Squish( s1 )

isPalindrome = ( squished = StrReverse( squished ) )

 

====Invocation====

wscript.echo isPalindrome( "Madam, I'm Adam.")

wscript.echo isPalindrome( "1 on 1")

{{out}}

<pre>0

This routine checks if current line is a palindrome:

 

EOL #2 = Cur_Col-2

BOL

if (CC(#1) != CC(#2-#1)) { Return(0) }

}

 

Testing:

 

if (Return_Value) {

Statline_Message("Yes")

Statline_Message("No")

}

 

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

{{trans|VBA}}

 

Function IsPalindrome(p As String) As Boolean

End Sub

 

{{out}}

<pre>True</pre>

 

=={{header|Wortel}}==

; Using a hook

pal1 @(= @rev)

!pal3 "In girum imus nocte et consumimur igni"

]]

Returns: <pre>[true false true]</pre>

 

=={{header|Wren}}==

 

System.print("Are the following palindromes?")

for (word in ["rotor", "rosetta", "step on no pets", "été", "wren", "🦊😀🦊"]) {

System.print(" %(word) => %(isPal.call(word))")

 

{{out}}

 

=={{header|X86 Assembly}}==

; x86_84 Linux nasm

section .text

mov rax, 1

ret

 

=={{header|XPL0}}==

string 0; \use zero-terminated strings

 

CrLf(0);

];

 

{{out}}

is_palindrome (by changing case and stripping non-alphabetical characters).

 

s = strchar(str)(:-1);

return allof(s == s(::-1));

w = where(s >= 'a' & s <= 'z');

return strchar(s(w));

 

=={{header|zkl}}==

if (text.len()<2) return(False);

text==text.reverse();

}

{{out}}

<pre>

 

=={{header|Zoea}}==

program: palindrome

case: 1

input: abc

output: false

 

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