Bestimmen Sie anhand eines Infix-Ausdrucks, ob alle Konstanten vom gleichen Typ sind.

Operatoren bestehen nur aus diesen dyadischen Operatoren:+-/*

Ihr Programm oder Ihre Funktion sollte eine gültige Ausdruckszeichenfolge als Eingabe verwenden und einen wahrheitsgemäßen Wert ausgeben, wenn die Konstanten im Ausdruck gleichzeitig sind, und ansonsten einen falschen Wert.

Der Ausdruck besteht ausschließlich aus Konstanten und kann einen der folgenden Typen enthalten:

• Zeichenfolge des Formulars "String"(Immer doppelte Anführungszeichen, kann leer sein, keine Escapezeichen, kann ASCII-Text enthalten)
• Ganzzahl der Form 14(Immer positiv oder Null)
• Float der Form 7.3f(Immer positiv oder Null, hat immer eine Dezimalkomponente, z. 14.0f)
• Byte der Form 0x42( 0-255, immer 2 hexadezimale Zeichen)
• Boolescher Wert in der Form true( trueoder ohne falseBerücksichtigung der Groß- und Kleinschreibung)

Der Ausdruck enthält keine Klammern, da die Reihenfolge der Operation den Typ nicht beeinflusst, wenn kein Typzwang vorhanden ist.

Eine einzelne Konstante ohne Operatoren ist ein gültiger Ausdruck.

Ein leerer Ausdruck ist kein gültiger Ausdruck.

Sie können davon ausgehen, dass die Ausdruckszeichenfolge kein Leerzeichen außerhalb von Zeichenfolgenliteralen enthält.
Hinweis: Alternativ können Sie davon ausgehen, dass zwischen Konstanten und Operatoren immer Leerzeichen vorhanden sind, wie in den Testfällen dargestellt. Wenn Sie diese Annahme treffen, geben Sie dies bitte in Ihrer Antwort an

Sie müssen nicht mit ungültigen Ausdrücken wie z 1 +.

Wertung

Dies ist Code-Golf , also gewinnen die wenigsten Bytes!

Testfälle

(Leerzeichen zur besseren Lesbarkeit hinzugefügt)

2 + 3
True

"Hello" / "World"
True

true * false
True

"Hello" + 4
False

"Hello" + "4"
True

3 + 2.4f / 8
False

0xff * 0xff
True

0xff + 2
False

6
True

" " + ""
True

"4 + false" + "word"
True

JavaScript (ES6),  79 77  75 Byte

2 Bytes dank @ExpiredData gespeichert

Erwartet Leerzeichen um Operatoren. Gibt einen booleschen Wert zurück.

s=>![/".*?"/g,/0x../g,/\S+f/g,/\d/,/e/i].filter(e=>s!=(s=s.split(e)+''))[1]

Probieren Sie es online aus!

Wie?

1. Wir entfernen alle Strings mit /".*?"/g
2. Wir entfernen alle Bytes mit /0x../g
3. Wir entfernen alle Schwimmer mit /\S+f/g
4. Wir suchen nach einer verbleibenden Ziffer mit /\d/; Wenn wir eine finden, muss es mindestens eine ganze Zahl geben
5. Wir suchen einen Rest "e"oder "E"mit /e/i; Wenn wir einen finden, muss es mindestens einen Booleschen Wert geben

Alle entfernten Ausdrücke werden tatsächlich durch ein Komma ersetzt, was harmlos ist.

Wir filtern die regulären Ausdrücke heraus, die keine Änderung an der Eingabezeichenfolge bewirken, und testen, ob am Ende des Prozesses weniger als zwei davon übrig bleiben.

Perl 5 -p , 73 Bytes

for$f(qw/".*?" \d+.\d+f 0x.. ....?e \d+/){s/$f//gi&&last}$_=/^[+\/* -]*$/

Probieren Sie es online aus!

Wie?

Versuchen Sie, Zeichenfolgen, Gleitkommazahlen, Hex, Boolesche Werte und Ganzzahlen in dieser Reihenfolge zu entfernen. Stoppen Sie, sobald etwas entfernt wird. Überprüfen Sie nach dem Stoppen, ob die verbleibende Zeichenfolge nur aus Operatoren und Leerzeichen besteht. Wenn dies der Fall ist, ist die Trype-Prüfung wahr. wenn nicht, ist es falsch.

Erster Versuch: Perl 5 -MList::Util=all -p, 99 Bytes

s/".*?"/!/g;for$f(qw/! \d+ \d+\.\d+f 0x[0-9a-f]{2} (true|false)/){$\||=all{/^$f$/i}/[^+\/* -]+/g}}{

Probieren Sie es online aus!

Gelee , 30 23 Bytes

ṣ”"ŒœḢYŒlḲŒœḢeþ@“.e¶x”E

Probieren Sie es online aus!

Eine monadische Verknüpfung, die eine Zeichenfolge als Eingabe verwendet und 1 für true und 0 für false zurückgibt (Jellys Boolesche Werte). Erwartet Leerzeichen um Operatoren.

Ich habe dem TIO einige neue Testfälle hinzugefügt, darunter einen mit drei Operatoren und einen mit einem gemischten Fall für Boolesche Werte.

Erläuterung

ṣ”"                     | Split input at double-quotes
   Œœ                   | Split into two lists, one of odd indices and one even. The even indices will have the contents of the quoted bits in the input (if any)
     Ḣ                  | Keep only the odd-indexed items
      Y                 | Join with newlines (so now all quoted strings in input are a single newline)
       Œl               | Convert to lower case (so that booleans are case insensitive)
         Ḳ              | Split at spaces
          ŒœḢ           | As before just take odd indices
             eþ@“.e¶x”  | Check for each section which they contain of .e¶x (respectively floats, booleans, strings and hex; integers will have none of these)
                      E | Check each section is equal (will return true for single section)

C # (Visual C # Interactive Compiler) , 113 111 109 Byte

n=>@""".*?"" 0x.. \S+f \d e|E".Split().Single(x=>n!=(n=System.Text.RegularExpressions.Regex.Replace(n,x,"")))

Port of Arnauld's Javascript Antwort . Ist 72 Bytes mit dem Flag /u:System.Text.RegularExpressions.Regex.

Probieren Sie es online aus!

Japt -! , 36 Bytes

`".*?" 0x.. %S+f %d e|E`¸è@UÀ(U=rXÃÉ

Versuch es

05AB1E , 50 24 Bytes

'"¡āÉÏ»lð¡āÉÏε".e
x"Så}Ë

-26 Bytes, indem Sie eine Portierung von @NickKennedys Jelly-Antwort machen , also stellen Sie sicher, dass Sie ihn positiv bewerten !!

Erwartet eine Eingabe mit Leerzeichen an den Operanden.

Probieren Sie es online aus oder überprüfen Sie alle (plus einige weitere) Testfälle .

Erläuterung:

'"¡         '# Split the (implicit) input-string by '"'
   āÉÏ       # Only keep all values at 0-based even indices
      »      # Join them by newlines
       l     # Converted to lowercase (for `true`/`false`)
ð¡           # Split by spaces (NOTE: `#` cannot be used here, since inputs without
             # operands wouldn't be wrapped inside a list)
  āÉÏ        # Keep all values at 0-based even indices again
     ε".e
     x"Så}   # Check for each item for each of [".","e","\n","x"] if it's in the item
          Ë  # Check if all inner lists are the same
             # (which is output implicitly as result)

Python 2 , 102 Bytes

import re
def f(s):
	m=map(eval,re.split('[*+-/]',s))
	return all(map(lambda t:type(t)==type(m[0]),m))

Probieren Sie es online aus!

Ich bin mir nicht ganz sicher, wie ich einige dieser Typen in Python darstellen soll. Zum Beispiel werden 0xff und 2 beide als ganze Zahlen behandelt. Und 2.4f ist kein gültiger Typ in Python, denke ich. Großgeschriebenes Richtig und Falsch zum Testen von Booleschen Werten.

Bearbeiten: Grammatik

Stax , 26 Bytes

ïd"┬Z\¡►L!8$lm╗╕╤☻ú≡╝ò6Å>^

Führen Sie es aus und debuggen Sie es

Dieses Programm erwartet Leerzeichen um die Operatoren. Im Allgemeinen werden einige Transformationen auf die Eingabe angewendet, sodass das maximale Zeichen für jeden Ausdruckstyp unterschiedlich ist.

Ausgepackt, ungolfed und kommentiert sieht es so aus.

i           suppress automatic evaluation of input
'"/2::'s*   replace quoted strings with 's'
.\d'9R      replace all digits with '9'
.ez|t       replace 'e' with 'z'
j2::        split on spaces, and discard alternating groups (operators)
{|Mm        calculate the maximum character in each remaining group
:u          resulting array contains exactly one distinct value

Führen Sie diesen aus

Haskell, 140 Bytes

r(a:t)|a=='"'=a:r(tail$snd$span(/=a)t)|elem a"+-*/"=r t|0<1=a:r t
r n=n
f x|z<-[last$'i':(filter(`elem`t)"fex\"")|t<-words$r x]=all(==z!!0)z