La tarea

En este desafío, su tarea es escribir un programa o función que tome una Cadena y genere un valor verdadero o falso en función de si el primer carácter y el último carácter de la Cadena de entrada son iguales.

Entrada

Puede tomar aportes de cualquier manera razonable. Sin embargo, asumir que la entrada está presente en una variable predefinida no está permitido. Se permite leer desde un archivo, consola, línea de comando, campo de entrada, etc., o tomar información como argumento de función.

Salida

Puede imprimir en cualquier formato razonable, excepto para asignar el resultado a una variable. Se permite escribir en un archivo, consola, línea de comando, cuadro modal, returndeclaraciones de funciones , etc.

Reglas Adicionales

• La entrada también puede ser una cadena vacía, para la cual debe devolver un valor falsey.

• Las cadenas de entrada de un solo carácter deberían tener un resultado verdadero.

• Su programa debe ser sensible a mayúsculas y minúsculas. helloHdebería generar un valor de falsey.

• Solo puede tener un único valor de Verdad y un solo valor de Falsey. Por ejemplo, la salida falsepara una Cadena de entrada y 0para otra Cadena de entrada como valores de Falsey no está permitida.

• Las lagunas estándar no están permitidas.

Casos de prueba

Input    ->    Output

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

Este es el código de golf , por lo que gana el código más corto en bytes.

Jalea , 3 bytes

=ṚḢ

Pruébalo en línea!

Python 3 , 23 bytes

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

La salida es a través del código de salida, por lo que 0 (éxito) es verdadero y 1 (fracaso) es falso. Si esto es aceptable, se puede guardar un byte.

Pruébalo en línea!

Cómo funciona

En primer lugar, si s es una cadena vacía, s[0]generará un IndexError , haciendo que el programa falle.

Para que no estén vacíos s , si los caracteres primero y último son iguales, s[0]!=s[-1]se evaluará como falso , por lo que el programa se cierra de forma limpia y de inmediato.

Finalmente, si los caracteres son diferentes, s[0]!=s[-1]se evaluará como Verdadero , haciendo que se realice la comparación s[-1]<e. Como e no está definido, eso genera un NameError .

Si no se desea compatibilidad con Python 2,

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

también funciona, ya que comparar una cadena con un número entero genera un TypeError .

JavaScript, 19 bytes

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

Mathematica, 15 bytes

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

Toma una gran variedad de caracteres. Lanza errores cuando la entrada está vacía pero puede ignorarse.

05AB1E , 4 bytes

S¬Q¤

Pruébalo en línea! o probar todas las pruebas

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 bytes

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

Pruébalo en línea! Incluye suite de prueba. Editar: Guardado 1 byte gracias a @Kobi.

C ++, 39 bytes

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

Programas completos:

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

Pruébalo en línea

Brachylog , 4 bytes

h~t?

Pruébalo en línea!

Explicación

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

Java, 81 77 bytes

• -4 bytes, gracias @KevinCruijssen

Probar en línea

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

• Devuelve truesi son iguales, de lo contrario false, falsepara una cadena vacía

Versión de matriz, 60 bytes

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

Python 2 , 26 25 24 bytes

¡Gracias a @Dennis por guardar un byte!

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

Pruébalo en línea!

brainfuck , 43 bytes

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

Pruébalo en línea!

Explicación

El bucle principal es [>[->+<<->],]. Después de cada iteración, la celda a la derecha de la posición actual es el primer byte de la cadena, y la celda a la izquierda es la diferencia entre el carácter manejado más recientemente y el primero. <[[-]-<]convierte el resultado final a -1 si no es cero, y el resto convierte -1 y 0 a 48 y 49 ("0" y "1") respectivamente.

Haskell , 21 bytes

ctoma a Stringy devuelve a Bool.

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

Pruébalo en línea!

• Si no fuera por cadenas vacías, esto podría haber sido de 16 bytes con c s=s!!0==last s.
• take 1sda una lista que es solo el primer elemento de, a smenos que sesté vacío, en cuyo caso también está vacío.
• last s error en una cadena vacía, pero la pereza de Haskell lo guarda: una cadena con un solo elemento siempre es diferente de la cadena vacía, sin evaluar su elemento.

MATL, 5 bytes

&=PO)

¡Pruébalo en MATL Online!

Explicación

       % 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

En el caso de que se deba manejar una cadena de entrada vacía, entonces algo como lo siguiente (8 bytes) funcionaría

&=POwhO)

Esta solución simplemente antepone 0a al frente de la matriz N x N de tal manera que para una entrada vacía, cuando la matriz está 0 x 0, todavía hay un 0valor que luego es agarrado por0)

Pruébalo en MATL Online

Japt , 6 bytes

tJ ¥Ug

Pruébalo en línea!

APL (Dyalog) , 4 bytes

⊃⌽=⊃

Pruébalo en línea!

Explicación

  =                     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.

Aquí está la razón por la que esto funciona en cadenas vacías. Aplicar ⊃a una cadena vacía devuelve un espacio . Pero invertir una cadena vacía aún devuelve una cadena vacía, por lo que comparar una cadena vacía con una cadena no vacía (en este caso ) da un vector numérico vacío. Y aplicar ⊃a un vector numérico vacío devuelve 0. Por lo tanto, pasar una cadena vacía devuelve 0.

Java, 52 43 bytes

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

Para que funcione, alimente esto en una función como la siguiente que hace que un lambda "vaya":

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

Ruby, 26 24 bytes

¡ Ahorré dos bytes gracias a @philomory !

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

Primera publicación en codegolf -))

PHP> = 7.1, 23 bytes

imprime 1 para igual y nada si el personaje es diferente

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

Rápido, 57 bytes

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

C #, 38 30 bytes

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

Guardado 8 bytes gracias a @raznagul.

R, 40 bytes

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

Gracias a Nitrodon por -2 bytes.

Gracias a MickyT por -8 bytes.

Prueba:

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

Salida:

> 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 bytes

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

Esta es mi primera vez usando> <> y jugando al golf de código, por lo que agradecería sugerencias útiles.

El código está en tres secciones básicas.

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

Hojas de cálculo de Google, 33 bytes

Toma la entrada de la celda [A1]y las salidas 1para la entrada veraz y 0para la entrada falsey.

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

Se observa que los paréntesis en Exact(yRight( se dejan sin cerrar ya que Google Sheets corrige esto automáticamente tan pronto como el usuario ingresa el texto de la fórmula y presiona Enter para salir de esa celda.

Salida

R 50 43 41 40 64

Segunda solución con 41 bytes para una función invocable, gracias a @ niczky12 y @Giuseppe, modificada para x = ""

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

Primero con 50 bytes pero no para el desafío

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

Octava, 16 bytes

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

Toma una cadena scomo entrada y compara el primer s(1)elemento con el último s(end).

Esto podría ser @(s)s(1)-s(end)si estaba bien de intercambio true/falsea false/true.

GNU grep , 12 bytes

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

Ejecutar en modo extendido o PCRE.

No sé si esto se considera trampa o no.

JavaScript, 20 bytes

Agregue f=al principio e invoque como f(arg).

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

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

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

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

Explicación

Esta función toma un argumento _. En el cuerpo de la función, _[0]==_.slice(-1)verifica si el primer elemento de _(en el 0índice th) es igual al último elemento del mismo y devuelve el apropiado trueo falsebooleano.

SILOS , 81 bytes

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

Pruébalo en línea!

Lisp común, 83 74 61 58 bytes

Original: 83 bytes

Acabo de comenzar a aprender Common Lisp, así que siento que estoy llevando un putter a un campo de prácticas. Debe haber algún tipo de macroasistencia recursiva o manipulación de matriz posible aquí que no estoy viendo.

Esta es una función anónima que acepta una cadena como entrada:

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

Prettified:

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

¡Me encantaría ver una solución más elegante!

Revisión 1: 74 bytes

¡Tengo que amar esas funciones de biblioteca estándar!

Feo:

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

Bonita:

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

Revisión 1.5: 61 bytes

Espacios en blanco!

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

Revisión 2: 58 bytes

Feo:

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

Bonita:

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

¡Eso es todo por ahora! Creo que ya soy más inteligente.

AWK, 29 34 bytes

Este podría estar engañando un poco, porque requiere invocar AWK con la opción:

`-F ''`

En GNU Awk puedes usar los sinónimos de forma larga:

`--field-separator=''`

Así que agregué 5 bytes al total para dar cuenta de esto.

Feo:

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

Bonita:

NR == 1
{
    a = $1
}

END
{
    print(a == $NF)
}