Você notou que este é um palíndromo?

Introduza
um número inteiro não negativo ou sequência que o represente

Saída
4 saídas possíveis, representando duas propriedades do número:

• é palíndromo
• complicado # 2

Propriedade complicada nº 2
Se number não for palíndromo, essa propriedade responde à pergunta "O primeiro e o último dígito têm a mesma paridade?"
Se number for palíndromo, essa propriedade responde à pergunta "O primeiro e o dígito médio têm a mesma paridade?". Para comprimentos pares, o dígito do meio é um dos dois dígitos centrais.

Exemplos

12345678 -> Falso Falso
Não é palíndromo, o primeiro e o último dígito têm paridade diferente

12345679 -> False True
Não é um palíndromo, o primeiro e o último dígitos têm a mesma paridade

12344321 -> Verdadeiro Falso
É palíndromo, o primeiro dígito 1 e o dígito médio 4 têm paridade diferente

123454321 -> Verdadeiro Verdadeiro
É palíndromo, o primeiro dígito 1 e o dígito médio 5 têm a mesma paridade

PS
Você decide o tipo e formato de saída. Pode haver 4 valores distintos. Apenas mencione isso na sua resposta.

05AB1E, 15 , 14 13 bytes (Agradecimentos a Riley e carusocomputing)

ÐRQi2ä¨}ȹRÈQ

Experimente on-line

Retorna entre colchetes se for um palíndromo

Retorna com 0 se a paridade for diferente, 1 se for a mesma

Ð Adicionar entrada, de modo que eu tenha entrada suficiente para trabalhar com

R Inverta o último elemento da pilha

Q Veja se é o mesmo (pega os dois elementos principais e executa ==)

i If, então só passa quando é um palíndromo

2 Empurre o número 2

ä Divida a entrada em 2 fatias iguais

¨ Empurre o primeiro elemento da divisão (1264621 resultados em 1264)

} Fim se

È Verifique se o último elemento é par

¹ Empurre a primeira entrada novamente

R Inverta essa entrada

È Verifique se é mesmo agora

Q Verifique se esses resultados são iguais e imprima implicitamente

PHP, 55 52 bytes

echo$p=strrev($n=$argn)==$n,$n-$n[$p*log($n,100)]&1;

recebe entrada do STDIN; corra com -R.

resultado:

• 10 para palíndromo e mesma paridade
• 11 para palíndromo e paridade diferente
• 0 para não palíndromo e mesma paridade
• 1 para não palíndromo e paridade diferente

notas:

• strlen($n)/2== log($n,10)/2==log($n,100)
• se palíndromo, compare o dígito do meio $n[1*log($n,100)]
• caso contrário, primeiro dígito $n[0*log($n,100)]
• ... para o número inteiro (<- bit mais baixo <- último dígito)

Geléia , 16 14 bytes

DµŒḂṄHC×LĊị+ḢḂ

Experimente online!

Produz duas linhas:

• 1para palíndromo, 0para não
• 0para complicado # 2 , 1para não

Explicação

DµŒḂṄHC×LĊị+ḢḂ    Main link. Argument: n (number)
D                 Get the digits of n
 µ                Start a new monadic chain
  ŒḂ              Check if the digit array is a palindrome (1 if yes, 0 if no)
    Ṅ             Print the result with a newline
     H            Halve (0.5 if palindrome, 0 if not)
      C           Subtract from 1 (0.5 if palindrome, 1 if not)
       ×          Multiply by...
        L         ...length of array (length/2 if palindrome, length if not)
         Ċ        Round up
          ị       Take item at that index from the digits
           +      Add...
            Ḣ     ...first item of digits
             Ḃ    Result modulo 2

Python 2 , 70 68 66 bytes

lambda n:(n==n[::-1],(ord(n[-1])+ord(n[(n==n[::-1])*len(n)/2]))&1)

Experimente online!

PowerShell , 114 99 bytes

param($n)((0,(($z=$n[0]%2)-eq$n[-1]%2)),(1,($z-eq$n[$n.length/2]%2)))[($n-eq-join$n[$n.length..0])]

Experimente online!

Economizou 15 bytes graças a @Sinusoid.

Entradas como uma sequência. Gera uma matriz do tipo (0|1) (True|False), com a 0indicação "não é um palíndromo" e a 1"palíndromo" indicadora, e a Trueparidade de indicação corresponde eFalse caso contrário.

Isso é feito usando um pseudo-ternário e indexando no local apropriado (a,b)[index]. O índice ($n-eq-join$n[$n.length..0])verifica se a entrada é um palíndromo. Caso contrário, tomamos a aparte, que é um 0acoplado a se a paridade do primeiro dígito $n[0]é -eqigual à paridade do último dígito $n[-1]. Caso contrário, estamos na bparte, que é um 1acoplado a se $z(a paridade do primeiro dígito) é -eqigual à paridade do dígito do meio$n[$n.length/2] .

Anteriormente, eu precisava "$($n[0])"obter o primeiro dígito para converter corretamente como um número inteiro, pois os $n[0]resultados em um chare no operador de módulo %coalescem chars com base no valor ASCII, não no valor literal, enquanto a stringfaz o valor literal. No entanto, o @Sinusoid me ajudou a ver que, 0,1,2,...,9como valores literais, todos têm a mesma paridade que 48,49,50,...,57, portanto, se ele usar o valor ASCII, ainda obteremos o mesmo resultado.

Essa matriz é deixada no pipeline e a saída é implícita.

VBA, 117 99 bytes

^{Economizou 18 bytes graças a Titus}

Sub p(s)
b=s
If s=StrReverse(s)Then r=2:b=Left(s,Len(s)/2+.1)
Debug.?r+(Left(s,1)-b And 1);
End Sub

Ele não se expande muito depois de formatado:

Sub p(s)
    b = s
    If s = StrReverse(s) Then r = 2: b = Left(s, Len(s) / 2 + 0.1)
    Debug.Print r + (Left(s, 1) - b And 1);
End Sub

Aqui estão os resultados dos casos de teste fornecidos:

s = 12345678     p(s) = 1 = False False
s = 12345679     p(s) = 0 = False True
s = 12344321     p(s) = 3 = True False
s = 123454321    p(s) = 2 = True True

Perl 6 , 48 bytes

{($/=.flip==$_),[==] .ords[0,($/??*/2!!*-1)]X%2}

Tente

resulta em (True True) (True False) (False True)ou(False False)

Expandido:

{                  # bare block lambda with implicit parameter ｢$_｣

  (
    $/ =           # store in ｢$/｣
    .flip == $_    # is ｢$_｣ equal backwards and forwards
  ),


  [==]             # reduce the following using &infix:<==> (are they equal)

    .ords\         # list of ordinals (short way to make ｢$_｣ indexable)
    [
      0,           # the first digit's ordinal
      (
        $/         # if the first test is True (palindrome)
        ??   * / 2 # get the value in the middle
        !!   * - 1 # else get the last value
      )
    ]
    X[%] 2         # cross those two values with 2 using the modulus operator
}

Java 8, 205 197 182 168 134 bytes

n->{int l=n.length(),a=n.charAt(0)%2;return n.equals(new StringBuffer(n).reverse()+"")?a==n.charAt(l/2)%2?4:3:a==n.charAt(l-1)%2?2:1;}

Saídas: 1para falso-falso; 2para falso-verdadeiro; 3para verdadeiro-falso; 4para verdadeiro-verdadeiro.

Explicação:

Experimente aqui.

n->{                     // Method with String parameter and integer return-type
  int l=n.length(),      //  The length of the input String
      a=n.charAt(0)%2,   //  Mod-2 of the first digit
  return n.equals(new StringBuffer(n).reverse()+"")?
                         //  If the String is a palindrome
    a==n.charAt(l/2)%2?  //   And if the first and middle digits are both even/odd
     4                   //    return 4
    :                    //   Else
     3                   //    Return 3
   :a==n.charAt(l-1)%2 ? //  Else-if the first and last digits are both even/odd
    2                    //   Return 2
   :                     //  Else
    1;                   //   Return 1
}                        // End of method

Haskell , 89 bytes

(x:r)#y=mod(sum$fromEnum<$>[x,y])2
f x|reverse x/=x=2+x#last x|y<-length x`div`2=x#(x!!y)

Experimente online! Uso: f "12345". Retorna 0para Verdadeiro Verdadeiro, 1Verdadeiro Falso, 2Falso Verdadeiro e 3Falso Falso.

A função #converte os dois caracteres de dígito em seus códigos de caracteres ASCII e os soma. Se ambos são pares ou ambos são ímpares, a soma será par; caso contrário, se um for par e o outro ímpar, a soma será ímpar. Calculando o módulo dois, #retorna 0para igual paridade e 1caso contrário. fverifica se a sequência de entrada xé um palíndromo. Se não, então #é chamado com xe o último caractere de xe dois é adicionado ao resultado, caso contrário, se xé chamada palindrômica #com o caractere do meio em xvez disso e deixa o resultado como está.

Kotlin , 142 bytes

fun Char.e()=toInt()%2==0;
val y=x.reversed()==x;val z=x.first();println("${y},${if(y)z.e()==x.get(x.length/2).e();else z.e()==x.last().e()}")

Experimente online!

fun Char.e() = toInt() % 2 == 0; //character extension function, returns if character(as int) is even

val y = x.reversed() == x
val z = x.first()

println(
"${y} //returns whether or not input is a palindrome
, //comma separator between the values
${if(y) z.e() == x.get(x.length/2).e() // if it's a palindrome compare first and middle parity
else z.e() == x.last().e()}" //else compare first and last parity
)

REXX, 104 100 bytes

arg a
parse var a b 2''-1 c
e=a=reverse(a)
b=b//2
if e then f=b&centre(a,1)//2
else f=b&c//2
say e f

Retorna o valor par lógica 0 0, 0 1, 1 0ou 1 1.

R, 115 109 105 bytes

w=strtoi(el(strsplit(scan(,""),"")))
c(p<-all(w==rev(w)),w[1]%%2==switch(p+1,tail(w,1),w[sum(1|w)/2])%%2)

Recebe entrada de stdin. Retorna FALSE FALSEpara Falso Falso, FALSE TRUEpara Falso Verdadeiro, TRUE FALSEpara Verdadeiro Falso e TRUE TRUEpara Verdadeiro Verdadeiro.

AWK, 97 96 bytes

{n=split($0,a,"")
for(;j<n/2;)s+=a[j+1]!=a[n-j++]
x=(a[1]%2==a[s?n:int(n/2)+1]%2)+(s?0:2)
$0=x}1

O uso mais simples é colocar o código no arquivo: OddEvenfaça:

awk -f OddEven <<< "some number here"

A saída é essencialmente a soma de bits das comparações na Questão, por exemplo,

0, Not palindrome and first and last digits have different parity
1, Not palindrome and first and last digits have same parity 
2, Palindrome and the first digit and middle digit have different parity
3, Palindrome and the first digit and middle digit have same parity

Eu tentei remover o ()de, (s?0:2)mas isso atrapalha a precedência do operador de alguma forma.

CJam, 32 bytes

q:N_W%=N0=~2%NW=~2%N_,2/=~2%3$?=

Entrada é um número no topo da pilha.

Explicação:

q                                 e# Read input:          | "12345679"
 :N                               e# Store in N:          | "12345679"
   _                              e# Duplicate:           | "12345679" "12345679"
    W%                            e# Reverse:             | "12345679" "97654321"
      =                           e# Check equality:      | 0
       N                          e# Push N:              | 0 "12345679"
        0=~                       e# First digit:         | 0 1
           2%                     e# Modulo 2:            | 0 1
             N                    e# Push N:              | 0 1 "12345679"
              W=~                 e# Get last digit:      | 0 1 9
                 2%               e# Modulo 2:            | 0 1 1
                   N              e# Push N:              | 0 1 1 "12345679"
                    _             e# Duplicate:           | 0 1 1 "12345679" "12345679"
                     ,            e# Length:              | 0 1 1 "12345679" 8
                      2/          e# Divide by 2:         | 0 1 1 "12345679" 4
                        =         e# Get digit (as char): | 0 1 1 '5
                         ~        e# Eval character       | 0 1 1 5
                          2%      e# Modulo 2:            | 0 1 1 1
                            3$    e# Copy stack element:  | 0 1 1 1 0
                              ?   e# Ternary operator:    | 0 1 1
                               =  e# Check equality:      | 0 1

Ruby , 60 + 1 = 61 bytes

Usa a -nbandeira.

r=->i{$_[i].to_i%2}
p e=$_.reverse==$_,r[0]==r[e ?~/$//2:-1]

Experimente online!

Groovy, 326 303 bytes

Código Encolhido:

String str="12345678";char pal,par;pal=str==str.reverse()?'P':'N';if(pal=='P'){par=(int)str.charAt(0).toString()%2==str.charAt((int)str.length()-1-(int)((str.length()-1)/2))%2?'S':'N'}else{par = (int)str.charAt(0).toString()%2==str.charAt((int)(str.length()-1)%2)?'S':'N'};print((String)pal+(String)par)

Código original (com explicação):

Declare str as String                        String str = "12345678"
Declare pal and par as char                  char pal, par
Check if Palindrome or not                   pal = str==str.reverse()?'P':'N'
If Palindrome...                             if (pal=='P') {
and has same parity (S) and if not (N)       par = (int)str.charAt(0).toString()%2==str.charAt((int)str.length()-1-(int)((str.length()-1)/2))%2?'S':'N'
else if not palindrome...                    } else {
and has same parity (S) and if not (N)       par = (int)str.charAt(0).toString()%2==str.charAt((int)(str.length()-1)%2)?'S':'N'
closing tag for if                           }
Print desired output                         print((String)pal+(String)par)

Código original (sem explicação):

String str = "12345678"
char pal, par
pal = str==str.reverse()?'P':'N'
if (pal=='P') {
    par = (int)str.charAt(0).toString()%2==str.charAt((int)str.length()-1-(int)((str.length()-1)/2))%2?'S':'N'
} else {
    par = (int)str.charAt(0).toString()%2==str.charAt((int)(str.length()-1)%2)?'S':'N'
}
print((String)pal+(String)par)

Entrada:

Just change "12345678" to another set of non-negative digits.

Resultado:

"PS" - Palindrome with Same Parity
"PN" - Palindrome with Diff Parity
"NS" - Non-palindrome with Same Parity
"NN" - Non-palindrome with Diff Parity