¿Te diste cuenta de que esto es un palíndromo?

Ingrese
un número entero no negativo o una cadena que lo represente

Salida
4 salidas posibles, que representan dos propiedades de número:

• es palindrome
• complicado # 2

Propiedad difícil # 2
Si el número no es palíndromo, esta propiedad responde a la pregunta "¿El primer y el último dígito tienen la misma paridad?"
Si el número es palíndromo, esta propiedad responde a la pregunta "¿El primer dígito y el medio tienen la misma paridad?". Para longitudes pares, el dígito del medio es uno de los dos dígitos centrales.

Ejemplos

12345678 -> Falso Falso
No es palíndromo, el primer y el último dígito tienen paridad diferente

12345679 -> Falso verdadero
No es palíndromo, el primer y el último dígito tienen la misma paridad

12344321 -> Verdadero Falso
Es palíndromo, el primer dígito 1 y el dígito medio 4 tienen paridad diferente

123454321 -> Verdadero Verdadero
Es palíndromo, el primer dígito 1 y el dígito medio 5 tienen la misma paridad

PD
Usted puede decidir el tipo y formato de salida. Podría ser cualquier 4 valores distintos. Solo mencionalo en tu respuesta.

05AB1E, 15 , 14 13 bytes (Gracias a Riley y carusocomputing)

ÐRQi2ä¨}ȹRÈQ

Probar en línea

Devuelve con paréntesis si es un palíndromo

Devuelve con 0 si la paridad es diferente, 1 si es la misma

Ð Agregar entrada, de modo que tenga suficiente entrada para trabajar con

R Invierte el último elemento de la pila

Q Mire si es lo mismo (toma los dos elementos superiores y realiza ==)

i Si la declaración, solo pasa cuando es un palíndromo

2 Empuja el número 2

ä Dividir la entrada en 2 partes iguales

¨ Empuje el primer elemento de la división (1264621 resulta en 1264)

} Terminara si

È Compruebe si el último elemento es par

¹ Empuje la primera entrada nuevamente

R Invierta esa entrada

È Comprueba si es incluso ahora

Q Compruebe si esos resultados pares son los mismos e imprima implícitamente

PHP, 55 52 bytes

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

toma entrada de STDIN; correr con -R.

salida:

• 10 para palíndromo y misma paridad
• 11 para palíndromo y paridad diferente
• 0 para no palíndromo y la misma paridad
• 1 para no palíndromo y paridad diferente

notas:

• strlen($n)/2== log($n,10)/2==log($n,100)
• si palíndromo, compare el dígito medio $n[1*log($n,100)]
• si no, primer dígito $n[0*log($n,100)]
• ... al número entero (<- bit más bajo <- último dígito)

Jalea , 16 14 bytes

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

Pruébalo en línea!

Salidas dos líneas:

• 1para palíndromo, 0para no
• 0para complicado # 2 , 1para no

Explicación

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)

Pruébalo en línea!

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

Pruébalo en línea!

Guardado 15 bytes gracias a @Sinusoid.

Entradas como una cadena. Emite una matriz de tipo (0|1) (True|False), con la 0indicación "no es un palíndromo" y la 1indicación "palíndromo", y la Trueparidad indicadora coincide y de lo Falsecontrario.

Esto se hace mediante el uso de un pseudoternario e indexación en el lugar apropiado (a,b)[index]. El índice ($n-eq-join$n[$n.length..0])verifica si la entrada es un palíndromo. Si no es así, tomamos la aporción, que se 0combina con si la paridad del primer dígito $n[0]es -equal a la paridad del último dígito $n[-1]. De lo contrario, estamos en la bparte, que se 1combina con si $z(la paridad del primer dígito) es-eq ual a la paridad del dígito del medio $n[$n.length/2].

Anteriormente, tenía "$($n[0])"que obtener el primer dígito para emitir correctamente como un entero, ya que los $n[0]resultados en a chary el operador de módulo se %unen en charfunción del valor ASCII, no del valor literal, mientras que a stringhace el valor literal. Sin embargo, @Sinusoid me ayudó a ver que, 0,1,2,...,9como valores literales, todos tienen la misma paridad que48,49,50,...,57 , por lo que si usa el valor ASCII, obtendremos el mismo resultado.

Esa matriz se deja en la tubería, y la salida es implícita.

VBA, 117 99 bytes

^{Guardado 18 bytes gracias 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

No se expande mucho una vez formateado:

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

Estos son los resultados del caso de prueba:

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}

Intentalo

resultados en (True True) (True False) (False True)o(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;}

Salidas: 1para falso-falso; 2para falso-verdadero; 3para verdadero-falso; 4por verdadero-verdadero.

Explicación:

Pruébalo aquí.

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)

Pruébalo en línea! Uso: f "12345". Devuelve 0para Verdadero Verdadero, 1para Verdadero Falso, 2para Falso Verdadero y3 para Falso Falso.

La función #convierte ambos caracteres de dígitos en sus códigos de caracteres ascii y los suma. Si ambos son pares o ambos son impares, la suma será par; de lo contrario, si uno es par y el otro impar, la suma será impar. Calculando el módulo dos, se #obtiene 0una paridad igual y de lo 1contrario. fcomprueba si la cadena de entrada xes un palíndromo. Si no #es así, se llama con xy el último carácter de xy dos se agrega al resultado; de lo contrario, si xse llama palindrómica #con el carácter medio de en su xlugar y deja el 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()}")

Pruébalo en línea!

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, 104100 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

Devuelve valor par lógico 0 0, 0 1, 1 0o 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)

Toma entrada de stdin. Devuelve FALSE FALSEpara Falso Falso, FALSE TRUEFalso Verdadero, TRUE FALSEVerdadero Falso y TRUE TRUEVerdadero Verdadero.

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

El uso más simple es colocar el código en el archivo: OddEvenluego hacer:

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

La salida es esencialmente la suma de bits de las comparaciones en la pregunta, p. Ej.

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

He intentado quitar la ()de (s?0:2), pero esta meta la pata de precedencia de los operadores de alguna manera.

CJam, 32 bytes

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

La entrada es un número en la parte superior de la pila.

Explicación:

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

Rubí , 60 + 1 = 61 bytes

Usa la -nbandera.

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

Pruébalo en línea!

Groovy, 326303 bytes

Código encogido:

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 (con explicación):

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 (sin explicación):

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.

Salida:

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