La tâche

Dans ce défi, votre tâche consiste à écrire un programme ou une fonction qui prend une chaîne et génère une valeur de vérité ou de falsey selon que le premier caractère et le dernier caractère de la chaîne d'entrée sont égaux.

Contribution

Vous pouvez prendre des entrées de toute manière raisonnable. Cependant, en supposant que l'entrée soit présente dans une variable prédéfinie, elle n'est pas autorisée. La lecture depuis un fichier, une console, une ligne de commande, un champ de saisie, etc., ou de prendre une entrée comme argument de fonction est autorisée.

Sortie

Vous pouvez sortir dans n'importe quel format raisonnable, sauf pour affecter le résultat à une variable. L'écriture dans un fichier, une console, une ligne de commande, une boîte modale, des returninstructions de fonction , etc. est autorisée.

Règles additionnelles

• L'entrée peut également être une chaîne vide, pour laquelle vous devez renvoyer une valeur falsey.

• Les chaînes d'entrée à caractère unique devraient avoir un résultat de vérité.

• Votre programme devrait être sensible à la casse. helloHdevrait produire une valeur de falsey.

• Vous ne pouvez avoir qu'une seule valeur Truthy et une seule valeur Falsey. Par exemple, la sortie falsepour une chaîne d'entrée et 0pour une autre chaîne d'entrée en tant que valeurs Falsey n'est pas autorisée.

• Les failles standard ne sont pas autorisées.

Cas de test

Input    ->    Output

"10h01"        Truthy
"Nothing"      Falsey
"Acccca"       Falsey
"wow!"         Falsey
"wow"          Truthy
"H"            Truthy
""             Falsey

C'est du code-golf , donc le code le plus court en octets gagne!

Gelée , 3 octets

=ṚḢ

Essayez-le en ligne!

Python 3 , 23 octets

s=input()
s[0]!=s[-1]<e

La sortie se fait par le code de sortie, donc 0 (succès) est la vérité et 1 (échec) est faux. Si cela est acceptable, un octet peut être sauvegardé.

Essayez-le en ligne!

Comment ça marche

Tout d'abord, si s est une chaîne vide, s[0]une erreur IndexError sera déclenchée , ce qui entraînera l'échec du programme.

Pour les non-vides s , si les premiers et derniers caractères sont égaux, s[0]!=s[-1]évaluera à faux , de sorte que les sorties du programme proprement et immédiatement.

Enfin, si les caractères sont différents, s[0]!=s[-1]sera évalué à True , ce qui entraînera l'exécution s[-1]<ede compairson . Puisque e n'est pas défini, cela génère une erreur NameError .

Si la compatibilité avec Python 2 n'est pas souhaitée,

s[0]!=s[-1]<3

fonctionne également, car comparer une chaîne avec un entier déclenche une erreur TypeError .

JavaScript, 19 octets

a=>a.endsWith(a[0])

Mathematica, 15 octets

#&@@#===Last@#&

Prend un tableau de caractères. Lance des erreurs lorsque l'entrée est vide mais peut être ignorée.

05AB1E , 4 octets

S¬Q¤

Essayez-le en ligne! ou essayer tous les tests

S    # Split the input into individual characters
 ¬   # Get the first character
  Q  # Check all characters for equality to the first
   ¤ # Get the last value i.e. head == tail

Retina , 13 à 12 octets

^(.)(.*\1)?$

Essayez-le en ligne! Comprend une suite de tests. Edit: 1 octet enregistré grâce à @Kobi.

C ++, 39 octets

[](auto s){return s[0]&&s[0]==s.back();}

Programmes complets:

#include <string>
#include <iostream>

using namespace std;

int main()
{
    string t = "";
    auto f = [](auto s){return s[0]&&s[0]==s.back();};
    cout << f(t);
}

Essayez-le en ligne

Brachylog , 4 octets

h~t?

Essayez-le en ligne!

Explication

h       The head of the Input...
 ~t?    ...is the tail of the Input

Java, 81 77 octets

• -4 octets, merci @KevinCruijssen

Essayez en ligne

boolean f(String s){int l=s.length();return l>0&&s.charAt(l-1)==s.charAt(0);}

• Retourne truesi elles sont égales, sinon false, falsepour une chaîne vide

Version tableau, 60 octets

boolean f(char[]s){int l=s.length;return l>0&&s[0]==s[l-1];}

Python 2 , 26 25 24 octets

Merci à Dennis avoir sauvegardé un octet!

lambda x:""<x[:1]==x[-1]

Essayez-le en ligne!

brainfuck , 43 octets

+>,[<,[>[->+<<->],]]<[[-]-<]-[----->+<]>--.

Essayez-le en ligne!

Explication

La boucle principale est [>[->+<<->],]. Après chaque itération, la cellule à droite de la position actuelle est le premier octet de la chaîne et la cellule à gauche est la différence entre le dernier caractère traité et le premier. <[[-]-<]convertit le résultat final en -1 s'il est différent de zéro et le reste convertit respectivement -1 et 0 en 48 et 49 ("0" et "1").

Haskell , 21 octets

cprend un Stringet retourne un Bool.

c s=take 1s==[last s]

Essayez-le en ligne!

• Sans les chaînes vides, cela aurait pu être 16 octets avec c s=s!!0==last s.
• take 1sdonne une liste qui n'est que le premier élément de sless sest vide, auquel cas il est également vide.
• last s erreur sur une chaîne vide, mais la paresse de Haskell l'enregistre: Une chaîne avec un seul élément est toujours différente de la chaîne vide, sans évaluer son élément.

MATL, 5 octets

&=PO)

Essayez-le sur MATL Online!

Explication

       % Implicitly grab input as a string (of length N)
&=     % Perform an element-wise equality check yielding an N x N matrix
P      % Flip this matrix up-down
O)     % Get the last value in the matrix (column-major ordering)
       % Implicitly display the result

Dans le cas où une chaîne d'entrée vide doit être traitée, alors quelque chose comme ce qui suit (8 octets) fonctionnerait

&=POwhO)

Cette solution ajoute simplement a 0devant la matrice N x N, de sorte que pour une entrée vide, lorsque la matrice est présente 0 x 0, il reste une 0valeur qui est ensuite saisie par0)

Essayez-le sur MATL Online

Japt , 6 octets

tJ ¥Ug

Essayez-le en ligne!

APL (Dyalog) , 4 octets

⊃⌽=⊃

Essayez-le en ligne!

Explication

  =                     Compare
   ⊃                    The first element of the right argument with
 ⌽                      The right argument reversed
                        This will return an array of the length of the reversed argument. Each element in the resulting array will be either 0 or 1 depending on whether the element at that position of the reversed argument equals the first element of the original right argument
                        So with argument 'abcda', we compare 'a' with each character in 'adcba' which results in the array 1 0 0 0 1
⊃                       From this result, pick the first element.

Voici la raison pour laquelle cela fonctionne sur les chaînes vides. L'application ⊃à une chaîne vide renvoie un espace . Mais inverser une chaîne vide renvoie toujours une chaîne vide. Par conséquent, comparer une chaîne vide avec une chaîne non vide (dans ce cas ) donne un vecteur numérique vide. Et s’appliquant ⊃à un vecteur vide numérique renvoie 0. Par conséquent, passer une chaîne vide revient 0.

Java, 52 43 octets

s->!s.isEmpty()&&s.endsWith(""+s.charAt(0))

Pour que cela fonctionne, introduisez-le dans une fonction telle que la suivante qui crée un lambda "actif":

private static boolean f(Function<String, Boolean> func, String value) {
  return func.apply(value);
}

Ruby, 26 à 24 octets

Enregistré deux octets grâce à @philomory !

->e{!!e[0]>0&&e[0]==e[-1]}

Premier post sur codegolf -))

PHP> = 7.1, 23 octets

affiche 1 pour égal et rien si le personnage est différent

<?=$argn[0]==$argn[-1];

Rapide, 57 octets

var s=readLine()!,a=Array(s.characters);a[0]==a.last ?1:0

C #, 38 30 octets

s=>s!=""&&s[0]==s[s.Length-1];

Sauvegardé 8 octets grâce à @raznagul.

R, 40 octets

function(x)x>""&&rev(y<-charToRaw(x))==y

Merci à Nitrodon pour -2 octets.

Merci à MickyT pour -8 octets.

Tester:

f=function(x)x>""&&rev(y<-charToRaw(x))==y
test <- c("10h01", "Nothing", "Acccca", "wow!", "wow", "H", "")
sapply(test, f)
all(sapply(test, f) == c(T, F, F, F, T, T, F))

Sortie:

> f=function(x)x>""&&rev(y<-charToRaw(x))==y
> test <- c("10h01", "Nothing", "Acccca", "wow!", "wow", "H", "")
> sapply(test, f)
  10h01 Nothing  Acccca    wow!     wow       H         
   TRUE   FALSE   FALSE   FALSE    TRUE    TRUE   FALSE 
> all(sapply(test, f) == c(T, F, F, F, T, T, F))
[1] TRUE

> <> , 39 33 octets

 2i&01. >~&-?v1v
  i:1+?!^01. >0>n;

C'est la première fois que j'utilise> <> et que je joue au golf, donc des suggestions utiles seraient les bienvenues.

Le code est en trois sections de base.

2i&01. Pushes an arbitrary number (2 in this case, this causes an empty string to print 0) onto the stack and puts the input's first character in the register.

>i:1+?!^01. Main loop. Pushes the next character onto the stack. If the string has been read completely, then go to the last section

>~&-?v1v
     >0>n;  Compare the first and last characters. Print 1 if they're the same, 0 if not

Feuilles Google, 33 octets

Prend l’entrée de la cellule [A1]et les sorties 1pour l’entrée vérité et l’ 0entrée falsey.

=(A1<>"")*Exact(Left(A1),Right(A1

Il est à noter que les parenthèses dans Exact(etRight( sont laissées non fermées car Google Sheets corrige cela automatiquement dès que l'utilisateur a saisi le texte de la formule et appuyé sur Entrée pour quitter cette cellule.

Sortie

R, 50 43 41 40 64

Deuxième solution avec 41 octets pour une fonction appelable - grâce à @ niczky12 & @Giuseppe - modifiée pour x = ""

r=function(x,y=utf8ToInt(x))ifelse(x=="","FALSE",(y==rev(y))[1])

D'abord avec 50 octets mais pas pour le challenge

function(x){charToRaw(x)[1]==rev(charToRaw(x))[1]}

Octave, 16 octets

@(s)s(1)==s(end)

Il faut une chaîne sen entrée et compare le premier s(1)élément avec le dernier s(end).

Cela pourrait être @(s)s(1)-s(end)si elle était OK pour échanger true/falseà false/true.

GNU grep , 12 octets

^(.)(.*\1)?$

Exécuter en mode étendu ou PCRE.

Je ne sais pas si c'est considéré comme de la triche ou non.

JavaScript, 20 octets

Ajouter f=au début et invoquer comme f(arg).

_=>_[0]==_.slice(-1)

f=_=>_[0]==_.slice(-1)

i.oninput = e => o.innerHTML = f(i.value);

<input id=i><pre id=o></pre>

Explication

Cette fonction prend en argument _. Dans le corps de la fonction, _[0]==_.slice(-1)vérifie si le premier élément de _(at 0th index) est égal au dernier élément de celui-ci et renvoie le type approprié trueou falsebooléen.

SILOS , 81 octets

loadLine
a=256
c=get a
lblb
t=s
s=get a
a+1
if s b
t-c
if t d
i+1
lbld
printInt i

Essayez-le en ligne!

Common Lisp, 83 74 61 58 octets

Original: 83 octets

Je viens tout juste d’apprendre l’apprentissage de Common Lisp, j’ai donc l’impression d’apporter un putter à un driving range. Il doit y avoir une sorte de macro de magie récursive ou de manipulation de tableau possible que je ne vois pas.

C'est une fonction anonyme qui accepte une chaîne en tant qu'entrée:

(lambda (s) (let ((n (- (length s) 1))) (when (> n 0) (eq (char s 0) (char s n)))))

Prettifié:

(lambda (s)
  (let ((n (- (length s) 1)))
    (when (> n 0)
      (eq (char s 0)
          (char s n)))))

J'aimerais voir une solution plus lisse!

Révision 1: 74 octets

Je dois aimer ces fonctions de la bibliothèque standard!

Laid:

(lambda (s) (when (> (length s) 0) (eq (elt s 0) (elt (reverse s) 0))))

Joli:

(lambda (s)
  (when (> (length s) 0)
    (eq (elt s 0)
        (elt (reverse s) 0))))

Révision 1.5: 61 octets

Les espaces blancs!

(lambda(s)(when(>(length s)0)(eq(elt s 0)(elt(reverse s)0))))

Révision 2: 58 octets

Laid:

(lambda(s)(and(>(length s)0)(not(mismatch s(reverse s)))))

Joli:

(lambda (s)
  (and (> (length s) 0)
       (not (mismatch s (reverse s)))))

C'est tout pour le moment! Je pense que je suis déjà plus intelligent.

AWK, 29 à 34 octets

Celui-ci pourrait tricher légèrement, car il nécessite d'appeler AWK avec l'option:

`-F ''`

Dans GNU Awk, vous pouvez utiliser les synonymes de forme longue:

`--field-separator=''`

J'ai donc ajouté 5 octets au total pour tenir compte de cela.

Laid:

NR==1{a=$1}END{print(a==$NF)}

Joli:

NR == 1
{
    a = $1
}

END
{
    print(a == $NF)
}