Hai notato che questo è un palindromo?

Immettere il
numero intero non negativo o la stringa che lo rappresenta

Uscita
4 possibili uscite, che rappresentano due proprietà del numero:

• è palindromo
• difficile # 2

Proprietà ingannevole # 2
Se il numero non è palindromo, questa proprietà risponde alla domanda "La prima e l' ultima cifra hanno la stessa parità?"
Se il numero è palindromo, questa struttura risponde alla domanda "Do il primo e centrale cifre hanno la stessa parità?". Per lunghezze pari, la cifra centrale è una delle due cifre centrali.

Esempi

12345678 -> Falso Falso
Non è palindromo, la prima e l'ultima cifra hanno parità diverse

12345679 -> Falso vero
Non è palindromo, la prima e l'ultima cifra hanno la stessa parità

12344321 -> True False
È palindromo, la prima cifra 1 e la cifra media 4 hanno parità diverse

123454321 -> True True
È palindromo, la prima cifra 1 e la cifra media 5 hanno la stessa parità

PS
Sei tu a decidere il tipo e il formato di output. Potrebbe essere qualsiasi 4 valori distinti. Basta menzionarlo nella tua risposta.

05AB1E, 15 , 14 13 byte (grazie a Riley e al carusocomputing)

ÐRQi2ä¨}ȹRÈQ

Prova online

Restituisce tra parentesi se è un palindromo

Restituisce con 0 se la parità è diversa, 1 se è uguale

Ð Aggiungi input, in modo che io abbia input sufficienti per lavorare

R Invertire l'ultimo elemento della pila

Q Guarda se è lo stesso (prende i due elementi principali ed esegue ==)

i Se la dichiarazione, così passa solo quando è un palindromo

2 Premere il numero 2

ä Dividi l'input in 2 sezioni uguali

¨ Spingere il primo elemento della divisione (1264621 risultati nel 1264)

} Finisci se

È Controlla se l'ultimo elemento è pari

¹ Premere di nuovo il primo input

R Invertire tale input

È Controlla se lo è anche adesso

Q Controlla se questi risultati pari sono uguali e stampa implicitamente

PHP, 55 52 byte

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

accetta input da STDIN; corri con -R.

produzione:

• 10 per palindromo e stessa parità
• 11 per palindromo e parità diversa
• 0 per non palindromo e stessa parità
• 1 per non palindromo e parità diversa

Appunti:

• strlen($n)/2== log($n,10)/2==log($n,100)
• se palindromo, confrontare la cifra media $n[1*log($n,100)]
• in caso contrario, prima cifra $n[0*log($n,100)]
• ... al numero intero (<- bit più basso <- ultima cifra)

Gelatina , 16 14 byte

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

Provalo online!

Emette due righe:

• 1per palindromo, 0per non
• 0per ingannevole # 2 , 1per non

Spiegazione

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 byte

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

Provalo online!

PowerShell , 114 99 byte

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

Provalo online!

15 byte salvati grazie a @Sinusoid.

Input come stringa. Emette una matrice di tipo (0|1) (True|False), con l' 0indicazione "non un palindromo" e l' 1indicazione "palindromo", e la Trueparità indicante corrisponde e in Falsealtro modo.

Questo viene fatto usando uno pseudo-ternario e indicizzando nella posizione appropriata (a,b)[index]. L'indice ($n-eq-join$n[$n.length..0])controlla se l'input è un palindromo. In caso contrario, prendiamo la aporzione, che è 0accoppiata al fatto che la parità della prima cifra $n[0]sia -equguale alla parità dell'ultima cifra $n[-1]. Altrimenti, siamo nella bparte, che è 1accoppiata con $z(la parità della prima cifra) è -equguale alla parità della cifra media$n[$n.length/2] .

In precedenza, dovevo "$($n[0])"eseguire il cast della prima cifra correttamente come numero intero, poiché i $n[0]risultati in a chare l'operatore modulo si %fondono in charbase al valore ASCII, non al valore letterale, mentre a stringfa il valore letterale. Tuttavia, @Sinusoid mi ha aiutato a vedere che 0,1,2,...,9poiché i valori letterali hanno tutti la stessa parità di 48,49,50,...,57, quindi se utilizza il valore ASCII otteniamo comunque lo stesso risultato.

Quell'array viene lasciato sulla pipeline e l'output è implicito.

VBA, 117 99 byte

^{Risparmiato 18 byte grazie 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

Non si espande molto una volta formattato:

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

Ecco i risultati del caso test fornito:

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 byte

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

Provalo

risulta in (True True) (True False) (False True)o(False False)

Allargato:

{                  # 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 byte

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

Uscite: 1per falso-falso; 2per falso vero; 3per vero-falso; 4per vero-vero.

Spiegazione:

Provalo qui.

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 byte

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

Provalo online! Uso: f "12345". Restituisce 0per True True, 1per True False, 2per False True e 3per False False.

La funzione #converte entrambi i caratteri numerici nei loro codici caratteri ASCII e li somma. Se entrambi sono pari o entrambi sono dispari la somma sarà pari, altrimenti se uno è pari e l'altro dispari la somma sarà dispari. Calcolo del modulo due, #ritorni 0per parità uguale e 1altro. fcontrolla se la stringa di input xè un palindromo. Altrimenti #viene chiamato con xe l'ultimo carattere di xe due viene aggiunto al risultato, altrimenti se invece xè una chiamata palindromica #con il carattere centrale di xe lascia il risultato così com'è.

Kotlin , 142 byte

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()}")

Provalo 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 byte

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

Restituisce coppia di valori logici 0 0, 0 1, 1 0o 1 1.

R, 115 109 105 byte

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)

Riceve input dallo stdin. Restituisce FALSE FALSEFalse False, FALSE TRUEFalse True, TRUE FALSETrue False e TRUE TRUETrue True.

AWK, 97 96 byte

{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

L'utilizzo più semplice è quello di inserire il codice nel file: OddEvenquindi fare:

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

L'output è essenzialmente la somma in bit dei confronti nella domanda, ad es

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

Ho provato a rimuovere il ()da (s?0:2)ma questo in qualche modo incasina la precedenza dell'operatore.

CJam, 32 byte

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

L'input è un numero in cima allo stack.

Spiegazione:

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

Rubino , 60 + 1 = 61 byte

Usa la -nbandiera.

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

Provalo online!

Groovy, 326 303 byte

Codice ridotto:

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)

Codice originale (con spiegazione):

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)

Codice originale (senza spiegazione):

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)

Ingresso:

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

Produzione:

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