Die Aufgabe

In dieser Herausforderung besteht Ihre Aufgabe darin, ein Programm oder eine Funktion zu schreiben, die einen String aufnimmt und einen Wahrheits- oder Falschwert ausgibt, je nachdem, ob das erste Zeichen und das letzte Zeichen des Eingabe-Strings gleich sind.

Eingang

Sie können Eingaben auf jede vernünftige Weise vornehmen. Unter der Annahme, dass die Eingabe in einer vordefinierten Variablen vorhanden ist, ist dies jedoch nicht zulässig. Das Lesen aus einer Datei, einer Konsole, einer Befehlszeile, einem Eingabefeld usw. oder die Eingabe als Funktionsargument ist zulässig.

Ausgabe

Sie können in jedem vernünftigen Format ausgeben, mit Ausnahme der Zuweisung des Ergebnisses zu einer Variablen. Das Schreiben in eine Datei, eine Konsole, eine Befehlszeile, eine modale Box, Funktionsanweisungen returnusw. ist zulässig.

Zusätzliche Regeln

• Die Eingabe kann auch ein leerer String sein, für den Sie einen falschen Wert zurückgeben sollten.

• Single-Char Input Strings sollten ein echtes Ergebnis haben.

• Ihr Programm sollte zwischen Groß- und Kleinschreibung unterscheiden. helloHsollte einen Falsey-Wert ausgeben.

• Sie können nur einen einzigen Wahrheitswert und einen einzigen Falsey-Wert haben. Beispielsweise ist die Ausgabe falsefür eine 0Eingabezeichenfolge und für eine andere Eingabezeichenfolge als False-Werte nicht zulässig.

• Standardlücken sind nicht erlaubt.

Testfälle

Input    ->    Output

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

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes!

Gelee , 3 Bytes

=ṚḢ

Probieren Sie es online!

Python 3 , 23 Bytes

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

Die Ausgabe erfolgt über den Exit-Code, daher ist 0 (Erfolg) wahr und 1 (Misserfolg) falsch. Wenn dies akzeptabel ist, kann ein Byte gespeichert werden.

Probieren Sie es online!

Wie es funktioniert

Wenn s eine leere Zeichenfolge ist, s[0]wird zunächst ein IndexError ausgelöst , wodurch das Programm fehlschlägt.

Wenn bei nicht leeren s das erste und das letzte Zeichen gleich sind, s[0]!=s[-1]wird False ausgewertet , sodass das Programm sauber und sofort beendet wird.

Wenn sich die Zeichen unterscheiden, s[0]!=s[-1]wird der Wert " True" ( Wahr) ausgewertet , wodurch der Vergleich s[-1]<edurchgeführt wird. Da e undefiniert ist, wird ein NameError ausgelöst .

Wenn keine Abwärtskompatibilität mit Python 2 gewünscht ist,

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

Funktioniert auch, da der Vergleich einer Zeichenfolge mit einer Ganzzahl einen TypeError auslöst .

JavaScript, 19 Bytes

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

Mathematica, 15 Bytes

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

Nimmt eine Reihe von Zeichen. Löst Fehler aus, wenn die Eingabe leer ist, aber ignoriert werden kann.

05AB1E , 4 Bytes

S¬Q¤

Probieren Sie es online! oder Probieren Sie alle Tests aus

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

Probieren Sie es online! Beinhaltet eine Testsuite. Bearbeiten: 1 Byte dank @Kobi gespeichert.

C ++, 39 Bytes

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

Vollständige Programme:

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

Probieren Sie es online aus

Brachylog , 4 Bytes

h~t?

Probieren Sie es online!

Erläuterung

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

Java, 81.77 Bytes

• -4 Bytes, danke @KevinCruijssen

Versuchen Sie es online

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

• Returns , truewenn sie sind gleich, sonst false, falsefür leere Zeichenfolge

Array-Version, 60 Byte

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

Python 2 , 26 25 24 Bytes

Vielen Dank an @Dennis für das Speichern eines Bytes!

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

Probieren Sie es online!

Brainfuck , 43 Bytes

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

Probieren Sie es online!

Erläuterung

Die Hauptschleife ist [>[->+<<->],]. Nach jeder Iteration ist die Zelle rechts von der aktuellen Position das erste Byte der Zeichenfolge, und die Zelle links ist die Differenz zwischen dem zuletzt verarbeiteten und dem ersten Zeichen. <[[-]-<]wandelt das Endergebnis in -1 um, wenn es nicht Null ist, und der Rest wandelt -1 und 0 in 48 und 49 ("0" bzw. "1") um.

Haskell , 21 Bytes

cnimmt a Stringund gibt a zurück Bool.

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

Probieren Sie es online!

• Wenn nicht für leere Zeichenfolgen, könnte dies 16 Bytes mit gewesen sein c s=s!!0==last s.
• take 1sGibt eine Liste aus, die nur das erste Element von ist, ssofern ses nicht leer ist. In diesem Fall ist es auch leer.
• last s würde bei einer leeren Zeichenfolge einen Fehler machen, aber Haskells Faulheit speichert ihn: Eine Zeichenfolge mit einem einzelnen Element unterscheidet sich immer von der leeren Zeichenfolge, ohne dass das Element ausgewertet wird.

MATL, 5 Bytes

&=PO)

Probieren Sie es bei MATL Online!

Erläuterung

       % 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

In dem Fall, dass eine leere Eingabezeichenfolge behandelt werden muss, würde so etwas wie die folgenden (8 Bytes) funktionieren

&=POwhO)

Diese Lösung stellt a einfach vor 0die Vorderseite der N x N-Matrix, sodass für eine leere Eingabe, wenn die Matrix vorhanden ist 0 x 0, immer noch ein 0Wert vorhanden ist, der dann von übernommen wird0)

Probieren Sie es bei MATL Online aus

Japt , 6 Bytes

tJ ¥Ug

Probieren Sie es online!

APL (Dyalog) , 4 Bytes

⊃⌽=⊃

Probieren Sie es online!

Erläuterung

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

Hier ist der Grund, warum dies bei leeren Zeichenfolgen funktioniert. Das Anwenden ⊃auf eine leere Zeichenfolge gibt ein Leerzeichen zurück . Das Umkehren einer leeren Zeichenfolge gibt jedoch immer noch eine leere Zeichenfolge zurück. Wenn Sie also eine leere Zeichenfolge mit einer nicht leeren Zeichenfolge vergleichen (in diesem Fall ), erhalten Sie einen leeren numerischen Vektor. Und das Anwenden ⊃auf einen leeren numerischen Vektor gibt zurück 0. Das Übergeben einer leeren Zeichenfolge führt daher zu einer Rückkehr 0.

Java, 52 43 Bytes

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

Um dies zu erreichen, geben Sie dies in eine Funktion wie die folgende ein, die ein Lambda "go" macht:

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

Ruby, 26 24 Bytes

Zwei Bytes dank @philomory gespart !

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

Erster Beitrag über Codegolf -))

PHP> = 7.1, 23 Bytes

Gibt 1 für gleich und nichts aus, wenn sich das Zeichen unterscheidet

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

Schnell, 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];

8 Bytes dank @raznagul gespeichert.

R, 40 Bytes

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

Danke an Nitrodon für -2 Bytes.

Vielen Dank an MickyT für -8 Bytes.

Prüfung:

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

Ausgabe:

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

Ich benutze zum ersten Mal> <> und spiele Codegolf, daher sind hilfreiche Vorschläge willkommen.

Der Code besteht aus drei grundlegenden Abschnitten.

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

Google Sheets, 33 Bytes

Nimmt Eingaben von Zelle [A1]und Ausgaben 1für wahrheitsgemäße Eingaben und 0für falsche Eingaben.

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

Es wird darauf hingewiesen, dass die Klammern in Exact(und Right(nicht geschlossen bleiben, da Google Sheets dies automatisch korrigiert, sobald der Benutzer den Formeltext eingegeben und die Eingabetaste gedrückt hat, um diese Zelle zu verlassen.

Ausgabe

R, 50 43 41 40 64

Zweite Lösung mit 41 Bytes für eine aufrufbare Funktion - dank @ niczky12 & @ Giuseppe - geändert für x = ""

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

Zuerst mit 50 Bytes, aber nicht für die Herausforderung

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

Oktave, 16 Bytes

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

Es nimmt einen String sals Eingabe und vergleicht das erste s(1)mit dem letzten Element s(end).

Dies könnte sein , @(s)s(1)-s(end)wenn es in Ordnung zu tauschen ist true/falsezu false/true.

GNU grep , 12 Bytes

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

Im erweiterten oder PCRE-Modus ausführen.

Ich weiß nicht, ob dies als Betrug angesehen wird oder nicht.

JavaScript, 20 Bytes

Fügen Sie f=am Anfang und rufen Sie wie f(arg).

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

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

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

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

Erläuterung

Diese Funktion nimmt ein Argument auf _. _[0]==_.slice(-1)Überprüft im Funktionskörper, ob das erste Element von _(am 0Index) dem letzten Element entspricht, und gibt den entsprechenden trueoder den falseBooleschen Wert zurück.

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

Probieren Sie es online!

Common Lisp, 83 74 61 58 Bytes

Original: 83 Bytes

Ich habe gerade angefangen, Common Lisp zu lernen, also habe ich das Gefühl, einen Putter auf eine Driving Range zu bringen. Hier muss eine Art rekursiver Makro-Assistenten oder Array-Manipulation möglich sein, die ich nicht sehe.

Dies ist eine anonyme Funktion, die eine Zeichenfolge als Eingabe akzeptiert:

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

Schön gemacht:

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

Würde gerne eine glattere Lösung sehen!

Revision 1: 74 Bytes

Muss ich lieben diese Standard-Bibliotheksfunktionen!

Hässlich:

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

Ziemlich:

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

Revision 1.5: 61 Bytes

Leerzeichen!

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

Revision 2: 58 Bytes

Hässlich:

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

Ziemlich:

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

Das ist alles für jetzt! Ich denke, ich bin schon schlauer.

AWK, 29 34 Bytes

Dieser kann leicht schummeln, da AWK mit der folgenden Option aufgerufen werden muss:

`-F ''`

In GNU Awk können Sie die Langform-Synonyme verwenden:

`--field-separator=''`

Also habe ich der Gesamtsumme 5 Bytes hinzugefügt, um dies zu berücksichtigen.

Hässlich:

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

Ziemlich:

NR == 1
{
    a = $1
}

END
{
    print(a == $NF)
}