Hinweis: Dies ist inspiriert von dieser Frage von @Willbeing, bei der es darum ging, die Anzahl der perfekten Teller einer bestimmten Länge zu zählen, aber es ist etwas anders.

Wir bezeichnen ein perfektes Kennzeichen als ein Kennzeichen , dessen Text die folgenden Bedingungen erfüllt:

• Es besteht aus Zeichen, die entweder Großbuchstaben ( [A-Z]) oder Ziffern ( [0-9]) sein können.
• Wenn man die Positionen seiner Buchstaben im englischen Alphabet summiert, ergibt 1-indiziert (dh A=1,B=2,...,Z=26:) eine ganze Zahl n
• Wenn Sie jeden Ziffernblock abrufen, summieren und dann alle Ergebnisse multiplizieren, erhalten Sie dasselbe Ergebnis, n
• n ist ein perfektes Quadrat (zB: 49 (7 ² ) , 16 (4 ² ) )

Ein nahezu perfektes Nummernschild erfüllt die Voraussetzungen für ein perfektes Kfz - Kennzeichen, außer dass n ist nicht ein perfektes Quadrat.

Eingang

Eine Zeichenfolge, die den Text des Kennzeichens darstellt und in einer beliebigen Standardform als Eingabe verwendet wird, mit Ausnahme der Hardcodierung.

Ausgabe

Wenn die angegebene Zeichenfolge ein nahezu perfektes Kennzeichen darstellt, geben Sie einen Wahrheitswert zurück (z. B.: True/ 1), andernfalls einen falschen Wert (z . B.: False/ 0). Jede Standardform der Ausgabe wird akzeptiert, wobei zu beachten ist, dass diese Lücken strengstens verboten sind.

Beispiele

licence plate -> output


A1B2C3 -> 1

A + B + C = 1 + 2 + 3 = 6
1 * 2 * 3 = 6 
6 is not a perfect square, 6 = 6 => nearly perfect plate

01G61 -> 1

(0 + 1) * (6 + 1) = 7
G = 7
7 is not a perfect square, 7 = 7 => nearly perfect plate

11BB2 -> 0

(1 + 1) * 2 = 4
B + B = 2 + 2 = 4
4 = 4, but 4 is the square of 2 => perfect license plate (not what we want)

67FF1 -> 0

(6 + 7) * 1 = 13
F + F = 6 + 6 = 12
12 != 13 => not perfect at all!

Wertung

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

Jelly , 29 28 30 Bytes

1 Byte um einen Fehler zu beheben , indem ChristianSievers getupft +1 Byte (fälschlicherweise mit Teil von nur Nullen zu tun) für Fehlalarme zu beheben "0", "00"... während über Befestigungs gefunden (0 ist ein perfekter Platz).

i@€ØAS;Ʋ$
e€ØAœpV€€LÐfS€P;0⁼Ç

Probieren Sie es online! oder führen Sie Tests durch

Wie?

i@€ØAS;Ʋ$ - Link 1: [letter-sum, letter-sum is perfect square?]: plate
i@€        - index of €ach char in plate [reversed @rguments] (1-based, 0 otherwise) in:
   ØA      -     uppercase alphabet
     S     - sum
         $ - last two links as a monad:
      ;    -     concatenate with:
       Ʋ  -         is square?

e€ØAœpV€€LÐfS€P;0⁼Ç - Main link: plate                        e.g. "11BB2"
    œp              - partition plate at truthy values of:
e€                  -     is in? for €ach char in plate:
  ØA                -         uppercase alphabet                   [['1','1'],[''],['2']]
      V€€           - evaluate for €ach for €ach                   [[1,1],[],[2]]
          Ðf        - filter keep:
         L          -     length                                   [[1,1],[2]]
            S€      - sum each                                     [2,2]
              P     - product                                      4
               ;0   - concatenate a zero                           [4,0]
                  Ç - last link (1) as a monad (taking plate)      [4,1]
                 ⁼  - equal? (non-vectorising)                     0

MATL, 36 34 33 35 Bytes

3Y432YXU"@V!Usvp]GlY2&msy=wtQ:qUm~v

Probieren Sie es bei MATL Online aus

Erläuterung

        % Implicitly grab input as a string
3Y4     % Push the predefined literal '[A-Za-z]+' to the stack
32      % Push the literal 32 to the stack (ASCII for ' ')
YX      % Replace the matched regex with spaces (puts a space in place of all letters)
U       % Convert the string to a number. The spaces make it such that each group of
        % of consecutive digits is made into a number
"       % For each of these numbers
  @V!U  % Break it into digits
  s     % Sum the digits
  v     % Vertically concatenate the entire stack
  p     % Compute the product of this vector
]       % End of for loop
G       % Explicitly grab the input again
lY2     % Push the predefined literal 'ABCD....XYZ' to the stack
&m      % Check membership of each character in the input in this array and 
        % return an array that is 0 where it wasn't a letter and the index in 'ABC..XYZ'
        % when it was a letter
s       % Sum the resulting vector
y       % Duplicate the product of the sums of digits result
=       % Compare to the sum of letter indices result
w       % Flip the top two stack elements
Q       % Add one to this value (N)
t:      % Duplicate and compute the array [1...N]
q       % Subtract 1 from this array to yield [0...N-1]
U       % Square all elements to create all perfect squares between 1 and N^2
m~      % Check to ensure that N is not in the array of perfect squares
v       % Vertically concatenate the stack.
        % Implicitly display the truthy/falsey result

Python 2, 120 - 118 Bytes

s=t=p=0;r=1
for n in input():
 h=int(n,36)
 if h>9:s+=h-9;r*=t**p
 p=h<10;t=(t+h)*p
print(s==r*t**p)&(int(s**.5)**2<s)

Probieren Sie es online!

Interpretiert jedes Zeichen als Zahl in base-36 ( h). Konvertiert in eine Dezimalzahl und addiert zur Summe if h>9(was bedeutet, dass es sich um einen Buchstaben handelt). Andernfalls wird eine Variable addiert, die später multipliziert wird, um das laufende Produkt zu bilden.

Perl 5 , 80 Bytes

79 Byte Code + -pFlag.

$.*=eval s/./+$&/gr for/\d+/g;$t-=64-ord for/\pl/g;$_=$.==$t&&($.**.5|0)**2!=$.

Probieren Sie es online!

$.*=eval s/./+$&/gr for/\d+/g;multipliziert die Summe aufeinanderfolgender Ziffern. (Ich benutze, $.weil es der Anfangswert ist 1, was bedeutet, dass es das neutrale Element für die Multiplikation ist.) Genauer gesagt, für jedes Stück von Ziffern ( for/\d+/g,) s/./+$&/grstellt einen +vor jeder Ziffer, dann wird der String evaluated, und mit dem aktuellen Produkt multipliziert.
Zweitens $t-=64-ord for/\pl/g;Summen in $tjedem Buchstaben ( for/\pl/g). ( ordGeben Sie den ASCII-Code für den Buchstaben zurück und geben 64-..Sie einen Wert zwischen 1 und 26 ein
. $.==$tÜberprüfen Sie abschließend , ob beide Werte gleich sind und ($.**.5|0)**2!=$.ob es sich nicht um ein perfektes Quadrat handelt.

Python 2, 267 207 Bytes

^{60 Bytes dank ovs gespart}

import re
def g(l):a=reduce(lambda a,b:a*b,[sum(map(int,list(i)))for i in re.sub(r'\D',' ',l).split()],1);return a==sum(sum(k)for k in[[ord(i)-64for i in x]for x in re.sub(r'\d',' ',l).split()])and a**.5%1>0

Funktion mit nutzung: print(g('A1B2C3'))

Probieren Sie es online!

Python 3 , 163 156 155 164 161 Bytes

from math import*
m=1;s=t=p=0
for x in input():
 try:t+=int(x);p=1
 except:m*=[1,t][p];p=t=0;s+=ord(x.upper())-64
if p:m*=t
print(m==s and sqrt(m)!=int(sqrt(m)))

Probieren Sie es online!

• 7 Bytes gespart dank Jonathan und Shooqie
• 1 Byte gespart: Auch das falsch-positive Problem wurde behoben. Vielen Dank an Jonathan für den Hinweis!
• 11 Bytes hinzugefügt: Vorherige Bearbeitung war falsch (die Multiplikation der Ziffernsumme fand in einer unerwünschten Schleife statt)

Retina, 143 Bytes

Gibt 1 für wahr, 0 für falsch zurück

[1-9]
$ *
10 | 01
1
S_` (\ D)
O`
{`1 (? = 1 * \ n (1+))
1 $
) 2 = `1 + \ n

[JS]
1 $ +
[TZ]
2 $ +
T`0L`ddd
1> `\ d + \ n?
$ *
^ ((& Alpha; (1) ((& alpha; (2) \ 2 (11) | 111)) | 1)) * \ n

^ (1 *) \ n \ 1 $

Probieren Sie es online!

Erläuterung:

[1-9]
$ *
10 | 01
1

Erstens ersetzen wir alle Ziffern ungleich Null durch ihre unäre Darstellung. Wir entfernen alle Nullen mit einer benachbarten Ziffer, damit sie unsere unären Operationen nicht beeinflussen

S_` (\ D)

Teilen Sie die resultierende Zeichenfolge in Buchstaben auf, und schließen Sie dabei Leerzeilen aus (dies ist ein Problem, wenn zwei Buchstaben hintereinander stehen AA).

O`
{`1 (? = 1 * \ n (1+))
1 $
) 2 = `1 + \ n

Sortieren Sie die Zeichenfolge lexikografisch. Führen Sie dann wiederholt Folgendes aus:

1) Ersetzen Sie jedes 1durch die Anzahl von 1s in der folgenden Zeile (dies ahmt die Multiplikation nach)

2) Entfernen Sie die zweite Zeile von 1s

[JS]
1 $ +
[TZ]
2 $ +
T`0L`ddd

Ersetzen Sie Buchstaben J-Smit 1J, 1Ketc. und ersetzen Briefe T-Zmit 2T, 2Uusw. Ersetzen Sie dann jede der Gruppen A-I, J-Sund T-Zmit 1-9. Wir werden mit dem numerischen Wert jedes Buchstabens belassen (zB 13für M).

1> `\ d + \ n?
$ *

Wandle jede Zeile außer der ersten in eine unäre um (die erste Zeile ist bereits unär). Verketten Sie diese Zeilen. Wir haben jetzt eine Zeichenfolge in der Form übrig <product of digits>\n<sum of letters>.

^ ((& Alpha; (1) ((& alpha; (2) \ 2 (11) | 111)) | 1)) * \ n

Ersetzen Sie eine quadratische Zahl durch die leere Zeichenfolge. Dies verwendet die "Differenzbaum" -Methode .

^ (1 *) \ n \ 1 $

Kehre zurück, 1wenn die beiden Saiten auf beiden Seiten des \nSpiels stehen. Andernfalls kehren Sie zurück 0.