Avez-vous remarqué qu'il s'agit d'un palindrome?

Entrez
un nombre entier non négatif ou une chaîne le représentant

Sortie
4 sorties possibles, représentant deux propriétés de nombre:

• est-ce palindrome
• délicat # 2

Propriété Tricky # 2
Si le nombre n'est pas palindrome, cette propriété répond à la question "Les premier et dernier chiffres ont-ils la même parité?"
Si le nombre est palindrome, cette propriété répond à la question "Le premier et le milieu ont-ils la même parité?". Pour les longueurs paires, le chiffre du milieu est l'un des deux chiffres du centre.

Exemples

12345678 -> Faux Faux
Ce n'est pas un palindrome, les premier et dernier chiffres ont une parité différente

12345679 -> Faux Vrai
Ce n'est pas un palindrome, les premier et dernier chiffres ont la même parité

12344321 -> Vrai Faux
C'est palindrome, le premier chiffre 1 et le chiffre du milieu 4 ont une parité différente

123454321 -> Vrai Vrai
C'est palindrome, le premier chiffre 1 et le chiffre du milieu 5 ont la même parité

PS
Vous êtes libre de décider du type et du format de sortie. Il peut s'agir de 4 valeurs distinctes. Mentionnez-le simplement dans votre réponse.

05AB1E, 15 , 14 13 octets (Merci à Riley et à carusocomputing)

ÐRQi2ä¨}ȹRÈQ

Essayez en ligne

Renvoie entre parenthèses s'il s'agit d'un palindrome

Renvoie 0 si la parité est différente, 1 si elle est la même

Ð Ajouter une entrée, de sorte que j'ai suffisamment d'entrée pour travailler avec

R Inverse le dernier élément de la pile

Q Regardez si c'est la même chose (prend les deux éléments supérieurs et exécute ==)

i Si la déclaration ne passe que lorsque c'est un palindrome

2 Appuyez sur le chiffre 2

ä Divisez l'entrée en 2 tranches égales

¨ Appuyez sur le premier élément de la scission (1264621 résultats en 1264)

} Fin si

È Vérifiez si le dernier élément est pair

¹ Appuyez à nouveau sur la première entrée

R Inverser cette entrée

È Vérifiez si c'est encore maintenant

Q Vérifiez si ces résultats pairs sont les mêmes et imprimez implicitement

PHP, 55 52 octets

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

prend l'entrée de STDIN; courir avec -R.

production:

• 10 pour palindrome et même parité
• 11 pour palindrome et parité différente
• 0 pour non-palindrome et même parité
• 1 pour non-palindrome et parité différente

Remarques:

• strlen($n)/2== log($n,10)/2==log($n,100)
• si palindrome, comparer le chiffre du milieu $n[1*log($n,100)]
• sinon, premier chiffre $n[0*log($n,100)]
• ... au nombre entier (<- bit le plus bas <- dernier chiffre)

Gelée , 16 14 octets

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

Essayez-le en ligne!

Produit deux lignes:

• 1pour palindrome, 0pour non
• 0pour délicat # 2 , 1pour ne pas

Explication

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 octets

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

Essayez-le en ligne!

PowerShell , 114 99 octets

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

Essayez-le en ligne!

15 octets enregistrés grâce à @Sinusoid.

Entrées sous forme de chaîne. Produit un tableau de type (0|1) (True|False), avec l' 0indication "pas un palindrome" et l' 1indication "palindrome", et l' Trueindication de parité correspond et Falseautrement.

Cela se fait en utilisant un pseudo-ternaire et une indexation à l'endroit approprié (a,b)[index]. L'index ($n-eq-join$n[$n.length..0])vérifie si l'entrée est un palindrome. Si ce n'est pas le cas, nous prenons la aportion, qui est un 0couplé avec si la parité du premier chiffre $n[0]est -eqégale à la parité du dernier chiffre $n[-1]. Sinon, nous sommes dans la bpartie, qui est 1couplée avec si $z(la parité du premier chiffre) est -eqégale à la parité du chiffre du milieu $n[$n.length/2].

Auparavant, je devais "$($n[0])"obtenir le premier chiffre à convertir correctement en entier, car les $n[0]résultats de a charet l'opérateur modulo %fusionnent chars en fonction de la valeur ASCII, pas de la valeur littérale, tandis que a stringfait la valeur littérale. Cependant, @Sinusoid m'a aidé à voir que 0,1,2,...,9les valeurs littérales ont toutes la même parité que 48,49,50,...,57, donc s'il utilise la valeur ASCII, nous obtenons toujours le même résultat.

Ce tableau est laissé sur le pipeline et la sortie est implicite.

VBA, 117 99 octets

^{Sauvegardé 18 octets grâce à 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

Il ne se développe pas beaucoup une fois formaté:

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

Voici les résultats des cas de test donnés:

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 octets

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

Essayez-le

résulte en (True True) (True False) (False True)ou(False False)

Étendu:

{                  # 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 182 168 134 octets

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

Sorties: 1pour faux-faux; 2pour faux-vrai; 3pour vrai-faux; 4pour vrai-vrai.

Explication:

Essayez-le ici.

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 octets

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

Essayez-le en ligne! Utilisation: f "12345". Renvoie 0True True, 1True True, 2False True et 3False False.

La fonction #convertit les deux caractères numériques en leurs codes de caractères ascii et les additionne. Si les deux sont pairs ou les deux sont impairs, la somme sera paire, sinon si l'un est pair et l'autre impair, la somme sera impaire. Calculer modulo deux, #renvoie 0pour une parité égale et 1autrement. fvérifie si la chaîne d'entrée xest un palindrome. Sinon, alors #est appelé avec xet le dernier caractère de xet deux est ajouté au résultat, sinon si xest un appel palindromique #avec le caractère du milieu à la xplace et laisse le résultat tel quel.

Kotlin , 142 octets

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

Essayez-le en ligne!

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 octets

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

Renvoie la paire de valeur logique 0 0, 0 1, 1 0ou 1 1.

R, 115 109 105 octets

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)

Prend l'entrée de stdin. Renvoie FALSE FALSEpour Faux Faux, FALSE TRUEpour Faux Vrai, TRUE FALSEpour Vrai Faux et TRUE TRUEpour Vrai Vrai.

AWK, 97 96 octets

{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'usage le plus simple est de placer le code dans un fichier: OddEvenensuite:

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

La sortie est essentiellement la somme des bits des comparaisons dans la question, par exemple

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

J'ai essayé de supprimer le ()de (s?0:2)mais cela gâche en quelque sorte la priorité des opérateurs.

CJam, 32 octets

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

L'entrée est un nombre au-dessus de la pile.

Explication:

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 octets

Utilise le -ndrapeau.

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

Essayez-le en ligne!

Groovy, 326 303 octets

Code réduit:

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)

Code d'origine (avec explication):

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)

Code d'origine (sans explication):

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)

Contribution:

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

Production:

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