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

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

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

of the remaining list here).

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