Un palindromo è una stringa che viene scritta allo stesso modo sia avanti che indietro. Ad esempio, "Eva, posso pugnalare i pipistrelli in una grotta?" è un palindromo (EVACANISTAB | BATSINACAVE)

Per questo codice golf, usando la lingua che preferisci, determina se una determinata stringa è o meno un palindromo.

Custodie per bordi:

• La punteggiatura non viene conteggiata per la pallidezza.
• I personaggi di controllo non vengono conteggiati per la pallidezza.
• Lo spazio bianco non viene conteggiato per la pallidezza.
• I numeri vengono conteggiati verso la pallidezza.
• Il caso in questa sfida non è conteggiato per la pallidezza.
• Non c'è limite alla lunghezza delle stringhe da valutare, ad eccezione di ciò che è imposto dalla tua lingua preferita.
• Per questa sfida, limitati al set di caratteri ASCII.

Requisiti tecnici:

• Sono necessari solo gli organismi metodo; cose aggiuntive come le firme dei metodi, le dichiarazioni sulla struttura dei dati, ecc. non contano ai fini del requisito di vittoria.
• Il codice deve essere compilato o interpretato senza errori o eccezioni durante la compilazione.
• Il codice non deve generare eccezioni o crash non gestiti. (Quasi inutile dirlo. Quasi.)
• Il codice deve restituire un valore che indica la pallidezza. Il tipo di dati dipende dalla lingua utilizzata (ad es. Un utente C # potrebbe utilizzare a bool, mentre un utente JavaScript potrebbe utilizzare a var.)
• Non è possibile scrivere il proprio interprete che esegue questa attività come una capacità "nativa" in modo da poter "giocare a golf" un punteggio quasi vincente. (Spero inutile dirlo.)

Condizioni di vittoria:

• Vince il codice più breve in caratteri.

Leader attuale: tmartin (k, 25 caratteri)

... Vuoi il segno di spunta verde magico dalla tua risposta? Batti la risposta di questo ragazzo!

K, 25

{x~|x:_x@&x in,/.Q`a`A`n}

.

k){x~|x:_x@&x in,/.Q`a`A`n}"Eva, can I stab bats in a cave?"
1b

Perl, 26 caratteri

s/_|\W//g;uc eq reverse uc

Valuta 1 quando $_è un palindromo ""(uno dei falsi valori di Perl) quando non lo è.

Esempio di utilizzo:

sub palin {
    s/_|\W//g;uc eq reverse uc
}
while (<DATA>) {
    chomp;
    print "$_ => ",palin()?"yes":"no","\n";
}
__DATA__
Eva, can I stab bats in a cave?
A man, a plan, a canal. Panama!
Madam, I'm Adam Corolla.
757
Boeing 757
A man, a plan, a big shovel, a canal. Panama!
A man, a plan, a canoe, pasta, heros, rajahs, a coloratura, maps, snipe, percale, macaroni, a gag, a banana bag, a tan, a tag, a banana bag again (or a camel), a crepe, pins, Spam, a rut, a Rolo, cash, a jar, sore hats, a peon, a canal >> __Panama__

produzione:

Eva, can I stab bats in a cave? => yes
A man, a plan, a canal. Panama! => yes
Madam, I'm Adam Corolla. => no
757 => yes
Boeing 757 => no
A man, a plan, a big shovel, a canal. Panama! => no
A man, a plan, a canoe, pasta, heros, rajahs, a coloratura, maps, snipe, percale, macaroni, a gag, a banana bag, a tan, a tag, a banana bag again (or a camel), a crepe, pins, Spam, a rut, a Rolo, cash, a jar, sore hats, a peon, a canal >> __Panama__ => yes

Solo C # 82 :)

var x=s.ToLower().Where(char.IsLetterOrDigit);return x.SequenceEqual(x.Reverse());

Non ho potuto resistere alla tentazione di scrivere un programma senza caldaia nella mia lingua preferita.

Un test è disponibile qui: http://ideone.com/8bwz7z

GolfScript, 36 34 31 30 caratteri

{0"0:A[a{"@{>^}+/},{32|}%.-1%=

Algoritmo simile alla mia precedente soluzione (Javascript) .

0"0:A[a{"@{>^}+/- Ottimizzato da Peter Taylor e Howard. La mia versione era "/9@Z"{1$<},,2%\;. Howard ha donato la concatenazione di funzioni e Peter Taylor ha donato XOR per modulo-2. È fondamentalmente un metodo generico per confrontare se il valore è in una sequenza di intervalli.

{.96>32*-}%(11 caratteri) non è davvero un miglioramento rispetto a Javascript .toUpperCase()(14 caratteri), soprattutto perché altera una strana punteggiatura che segue znella tabella ASCII (che non ha importanza qui).

come suggerito da Peter Taylor, tuttavia, se prima filtriamo gli alfanumerici, possiamo convertire in minuscole e cifre semplicemente impostando un bit in ciascun carattere: {32|}

.-1%=fa tutto il sollevamento palindromico pesante. Una parte di cui non sono molto affezionato è il tempo impiegato a scoprire come invertire un array. Avrei dovuto leggere i documenti. Gli altri due personaggi eseguono la gestione e il confronto dello stack.

Test: http://golfscript.apphb.com/?c=IkV2YSwgY2FuIEkgc3RhYiBiYXRzIGluIGEgY2F2ZT8iCgp7IjA6QVtheyJcez59KywsMiV9LHszMnx9JS4tMSU9

Inoltre, se posso presumere che non sia presente nessuno dei seguenti caratteri di controllo: (Uscita collegamento dati, controllo dispositivo 1-4, riconoscimento negativo, inattività sincrono, fine blocco di trasmissione, annullamento, fine del mezzo) (siamo tutti d'accordo che questi sono tutti piuttosto oscuri) o se posso trattarli come versioni maiuscole delle cifre 0-9, possiamo salvare altri due caratteri:

GolfScript, 28 caratteri

{32|}%{0"0:a{"@{>^}+/},.-1%=

Test: http://golfscript.apphb.com/?c=IkV2YSwgY2FuIEkgc3RhYiBiYXRzIGluIGEgY2F2ZT8iCgp7MzJ8fSV7MCIwOmF7IkB7Pl59Ky99LC4tMSU9

Javascript, 53 caratteri:

(x=x.toLowerCase().match(/[a-z\d]/g))+""==x.reverse()

è un'espressione javascript che restituisce true se x è un palindromo, falso se non lo è. Presuppone xè una stringa. Se ciò non è garantito, anteporrex+="",

Ecco un pangrattato: grazie a come reverse()funziona,

(x=x.toLowerCase().match(/[a-z\d]/g))==""+x.reverse()

non riesce. Tuttavia,

""+(x=x.toLowerCase().match(/[a-z\d]/g))==x.reverse()

va benissimo.

R: 66

w=grep("[a-z0-9]",strsplit(tolower(s),"")[[1]],v=T);all(w==rev(w))

Uso:

f=function(s){w=grep("[a-z0-9]",strsplit(tolower(s),"")[[1]],v=T);all(w==rev(w))}

f("Eva, can I stab bats in a cave?")
[1] TRUE

Bash: 52 48 46 caratteri

s=${1,,};s=${s//[^a-z0-9]};[ $s = `rev<<<$s` ]

Questo richiede la puntura per verificare come primo parametro e imposta il codice di uscita su 0 per palindromo e 1 per non.

Esecuzione di esempio:

bash-4.2$ p() { s=${1,,};s=${s//[^a-z0-9]};[ $s = `rev<<<$s` ]; }

bash-4.2$ p 'Eva, can I stab bats in a cave?'; echo $?
0

bash-4.2$ p 'A man, a plan, a canal. Panama!'; echo $?
0

bash-4.2$ p "Madam, I'm Adam Corolla."; echo $?
1

bash-4.2$ p '757'; echo $?
0

bash-4.2$ p 'Boeing 757'; echo $?
1

bash-4.2$ p 'A man, a plan, a shovel, a canal. Panama!'; echo $?
1

bash-4.2$ p 'A_man,_a_plan, a_caremer, a canal:_Panama!'; echo $?
0

Python 2: 49 (senza contare la firma del metodo)

def f(s):
 s=filter(str.isalnum,s.upper())
 return s==s[::-1]

Un programma completo, con input e output può essere scritto in 74 caratteri.

import sys
s=filter(str.isalnum,sys.stdin.read().upper())
print s==s[::-1]

Esempio di utilizzo:

$echo 'Eva,can I stab bats in a cave?' | python palindrome.py
True 
$ cat huge_palindrome.txt | python palindrome.py
True
$echo 'Able was I ere i SaW elBa' | python palindrome.py                                                                   
True                                         

( huge_palindrome.txtcontiene questo parola 17.826 palindromo)

Questa soluzione può essere adattata a Python 3 aggiungendo alcuni caratteri:

Python 3: 55

def f(s):
 s=list(filter(str.isalnum,s.upper()))
 return s==s[::-1]

JAVA (o la lingua più dettagliata di sempre), 102 96 95 caratteri

s=s.replaceAll("\\W|_","");return s.equalsIgnoreCase(new StringBuffer(s).reverse().toString());

Utilizzo (con codice non golfizzato):

static boolean q(String s) {
    s=s.replaceAll("\\W|_","");
    return s.equalsIgnoreCase(new StringBuffer(s).reverse().toString());
}

public static void main(String[] args) {
    System.out.println(q("'A man, a plan, a canal - Panama!'"));
}

Accorciato con l'aiuto del commentatore qui sotto

Mathematica 54 53

Un byte salvato grazie a CatsAreFluffy:

PalindromeQ@StringCases[ToUpperCase@#,WordCharacter]&

Per quelli con la versione 10.2 o precedente:

#==Reverse@#&@StringCases[ToUpperCase@#,WordCharacter]&

Esempio

PalindromeQ@StringCases[ToUpperCase@#, WordCharacter]&["Eva,can I stab bats in a cave?"]

Vero

J, 30 caratteri

*/(=|.)tolower(#~'[^_\W]'rxE])

Uso:

   */(=|.)tolower(#~'[^_\W]'rxE])'A man, a plan, a canal - Panama!'
1
   */(=|.)tolower(#~'[^_\W]'rxE])'Doc, note: I dissent. A fast never prevents a fatness. I diet on cod'
1

k ( 50 48 45 38 caratteri)

Elimina tutti gli errori, restituendo un valore predefinito di 0b(false).

{X~|X@:&(X:_:x)in 10h$(48+!10),97+!26}

Esempio:

k){X~|X@:&(X:_:x)in 10h$(48+!10),97+!26} "Eva, can I stab bats in a cave?"
1b

modifica: rasato altri tre caratteri evitando la variabile intermedia. H / T, CS. -7: non è necessario eliminare gli errori.

Rubino: 43 38 caratteri

s=s.upcase.tr'^A-Z0-9','';s==s.reverse

Esecuzione di esempio:

irb(main):001:0> p=->s{s=s.upcase.tr'^A-Z0-9','';s==s.reverse}
=> #<Proc:0x854592c@(irb):1 (lambda)>

irb(main):002:0> p['Eva, can I stab bats in a cave?']
=> true

irb(main):003:0> p['A man, a plan, a canal. Panama!']
=> true

irb(main):004:0> p["Madam, I'm Adam Corolla."]
=> false

irb(main):005:0> p['757']
=> true

irb(main):006:0> p['Boeing 757']
=> false

irb(main):007:0> p['A man, a plan, a shovel, a canal. Panama!']
=> false

irb(main):009:0> p['A_man,_a_plan, a_caremer, a canal:_Panama!']
=> true

C ++, 107 (Miscounted), 100 (contato male), 81

string s;for(int c:t)if(isalnum(c))s+=c|32;return s==string(s.rbegin(),s.rend());

• Sfrutta i pattern di bit ASCII.
• Si affida a un male using namespace std;.
• Utilizza AND bit OR e OR invece degli operatori logici.

• Utilizza intperché è più breve di charo auto.

  #include <string>
  using namespace std;
  
  bool IsPalindrome(const string & t) {
  string s;for(int c:t)if(isalnum(c))s+=c|32;return s==string(s.rbegin(),s.rend());
  }
  
  #include <cassert>
  
  int main() {
      assert(!IsPalindrome("gorilla"));  // simple failure
      assert( IsPalindrome("racecar"));  // simple success
      assert( IsPalindrome("Hannah"));   // case blind
      assert(!IsPalindrome("1999"));     // digit failure
      assert( IsPalindrome("2002"));     // digit success
      // Ignore spacing, punctuation, and case:
      assert( IsPalindrome(" \t09AZ/:@[`{za90"));  // boundaries
      assert( IsPalindrome("A man, a plan, a canal: Panama."));
      assert( IsPalindrome("Eva, can I stab bats in a cave?"));
      assert( IsPalindrome(""));  // empty string
      return 0;
  }
  

Lua, 56

a=io.read"*l":lower():gsub("%W","")print(a:reverse()==a)

Python 3/2 59 caratteri:

def pld(i):
   p=[c for c in i.lower() if c.isalnum()]
   return(p == p[::-1])

Haskell, 43

Utilizzando le librerie standard Control.Monad, Control.Monad.Instancese Data.Char:

ap(==)reverse.map toLower.filter isAlphaNum

PHP 60 caratteri.

Prima prova su codegolf.

//thank you manatwork
echo($x=preg_replace('/\W/','',strtolower($c)))==strrev($x); 

Esempio:

$c='Eva, can I stab bats in a cave?';
echo($x=preg_replace('/\W/','',strtolower($c)))==strrev($x);
//prints 1

Personaggi Python 2 64:

i =''.join(re.findall('[a-z0-9]+',i.lower()))
return i==i[::-1]

Haskell 48

(\x->x==reverse x).map toLower.filter isAlphaNum

usato così:

(\x->x==reverse x).map toLower.filter isAlphaNum$"Eva, can I stab bats in a cave?"

Caratteri Smalltalk , Squeak / Pharo
116 caratteri usando la formattazione tradizionale con schede

Aggiungi due metodi a String:

selffles
    ^self = self reverse
isPalindrome
    ^(self asUppercase asDecomposedUnicode select: #isAlphaNumeric) selffles

Ovviamente potremmo eliminare alcuni spazi o usare nomi di metodi più brevi, ma non tradiamo lo spirito di Smalltalk.

Inoltre, questo gestirà i palindromi francesi, come in http://fr.wikipedia.org/wiki/Liste_de_palindromes_fran%C3%A7ais , non molte risposte in questa pagina possono.

['Léon a trop par rapport à Noël' isPalindrome] assert.

Python 3 (51 caratteri)

e potrebbe essere Python 2

basato sulla soluzione di abhiram (con golf più aggressivo)

from re import findall

def palindrome(i):
 i=findall('[a-z\d]',i.lower())
 return i==i[::-1]

print(palindrome(input('Phrase: ')))

può essere ridotto a 46 caratteri, usando RE '\ w'

e variante con corpo funzione estremamente ridotto (27 caratteri)

import re
l=str.lower
f=re.compile('[a-z\d]').findall

def palindrome(i):i=f(l(i));return i==i[::-1]

print(palindrome(input('Phrase: ')))

Windows PowerShell, 56 47 45 caratteri

Aggiornato (vedi commenti) e può rimuovere le parentesi attorno alla regex:

($s=$s-replace'\W')-eq(-join$s[$s.length..0])

Originale (56)

$s=$s-replace'[^\w]','';$s-eq($s[-1..-$s.length]-join'')

Senza golf originale:

$s = "Eva, can I stab bats in a cave?"
$s = $s -replace '[^\w]', ''
$rev = $s[-1..-$s.length] -join ''
$s -eq $rev

C ++, 74 byte

Questo codice è in realtà molto elegante e facile da capire (se formattato correttamente). Non credo che sia possibile abbreviare in C ++ e non utilizza alcuna funzione di libreria standard.

p(auto c){auto e=c;while(*e)++e;--e;while(*e==*c&e>c)--e,++c;return e<=c;}

Esempio di utilizzo:

p("Hello"); //Outputs 0
p(""); //Outputs 1
p("a"); //Outputs 1
p("HellolleH"); //Outputs 1

Versione ben formattata:

p(auto c)
{
    auto e=c;
    while(*e) ++e;
    --e;
    while(*e==*c & e>c)--e,++c;
    return e<=c;
}

PHP, 26 84 80 78 62 63 byte

<?=strrev($s=strtolower(preg_replace("#\W#","",$argv[1])))==$s;

accetta input dal primo argomento della riga di comando; stampe 1per verità, stringa vuota per falsità.

I18n è un po 'espansivo, in quanto non esiste un'alternativa multibyte per strrev(110 byte; eseguire con -r):

preg_match_all("#.#us",$s=strtolower(preg_replace("#\W#u","",$argv[1])),$m);echo$s==join(array_reverse($m[0]);

utf8_strrev palesemente rubato dal manuale di PHP . Potresti anche dare un'occhiata a questo post sul blog .

Ruby, 48

p((g=gets.upcase.gsub /[^A-Z\d]/,'')==g.reverse)

Abbastanza semplice e fatto in fretta, quindi non ha giocato a golf troppo. Lo golfò più tardi.

Pylongolf2 , 24 byte

c╨2"[^a-zA-Z]"-_╨1=~

caccetta l'input, ╨2per convertirlo in minuscolo.
Quindi inserisco una regex nello stack e utilizzo -per rimuovere tutti i caratteri non alfabetici nell'input.
_duplica l'input.
╨1lo inverte e =poi li confronta.
~stampa la pila alla fine che stampa trueo false.

PowerShell, 194 190 byte

Un'implementazione ricorsiva per mostrare come un blocco script PowerShell senza nome può chiamare se stesso.

$P={param([string]$s)$s=($s-replace'[^a-z]').tolower();if(!$s){return $true};if($s.length-lt4){return $s[0]-eq$s[-1]};$s[0]-eq$s[-1]-and(&$MyInvocation.MyCommand.ScriptBlock $s.trim($s[0]))}

ungolfed:

$P={
param([string]$s)
$s=($s-replace'[^a-z]').tolower();
if(!$s){return $true};
if($s.length-lt4){return $s[0]-eq$s[-1]};
$s[0]-eq$s[-1]-and(&$MyInvocation.MyCommand.ScriptBlock $s.trim($s[0]))
}

test:

&$P "Eva, can I stab bats in a cave?"
&$P "Eva, can I stab cats in a cave?"
&$P "A man, a plan, a canal. Panama!"
&$P "A man, a plan, a big shovel, a canal. Panama!"
&$P "Madam, I'm Adam."
&$P "Madam, I'm Adam Corolla."
&$P "757"
&$P "Boeing 757"

05AB1E , 4 byte (non concorrenti)

Non competitiva , poiché la lingua postdatizza la sfida. Codice:

álÂQ

Spiegazione:

á     # Only keep the alphabetic characters.
 l    # Lowercase the characters.
  Â   # Bifurcate, which duplicates the letters and reverses the duplicate.
   Q  # Check if they are equal.

Utilizza la codifica CP-1252 . Provalo online! .

Gelatina, 10 personaggi (non competitivi)

fØBŒl
UÇ⁼Ç

Restituisce 1 se vero, 0 se falso

Provalo online!