Nota: Esto se inspira en esta pregunta de @Willbeing, donde la tarea consistía en contar el número de platos perfectos de cierta longitud, pero es ligeramente diferente.

Llamamos a una placa perfecta aquella placa cuyo texto cumple las siguientes condiciones:

• Se compone de caracteres, que pueden ser letras mayúsculas ( [A-Z]) o dígitos ( [0-9])
• Sumando las posiciones de sus letras en el alfabeto inglés, 1 indexado (es decir:) A=1,B=2,...,Z=26da un número entero n
• Obtener cada trozo de dígitos, sumarlos y luego multiplicar todos los resultados da el mismo resultado, n
• n es un cuadrado perfecto (por ejemplo: 49 (7 ² ) , 16 (4 ² ) )

Una matrícula casi perfecta cumple las condiciones para una matrícula perfecta, excepto que n no es un cuadrado perfecto.

Entrada

Una cadena que representa el texto de la matrícula, tomada como entrada en cualquier forma estándar, excepto para la codificación fija.

Salida

Si la cadena dada representa una placa casi perfecta , devuelva un valor verdadero (por ejemplo: True/ 1), de lo contrario, devuelva un valor falso (por ejemplo: False/ 0). Se acepta cualquier forma estándar de salida al tomar nota de que estas lagunas están estrictamente prohibidas.

Ejemplos

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!

Puntuación

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

Jalea , 29 28 30 bytes

1 byte para corregir un error descubierto por ChristianSievers (incorrectamente tratar con subcadenas de sólo ceros) 1 byte para fijar los falsos positivos para "0", "00", ... encuentra durante la fijación anterior (0 es un cuadrado perfecto).

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

Pruébalo en línea! o ejecutar pruebas

¿Cómo?

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

Pruébalo en MATL Online

Explicación

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

Pruébalo en línea!

Interpreta cada personaje como un número en base-36 ( h). Convierte a decimal y agrega a la suma if h>9(lo que significa que es una letra), de lo contrario agrega a una variable que se multiplica para formar el producto en ejecución más tarde.

Perl 5 , 80 bytes

79 bytes de código + -pbandera.

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

Pruébalo en línea!

$.*=eval s/./+$&/gr for/\d+/g;multiplica las sumas de dígitos consecutivos. (Estoy usando $.porque su valor inicial es 1, lo que significa que es el elemento neutral para la multiplicación). Más precisamente, para cada porción de dígitos ( for/\d+/g), s/./+$&/grcoloca un +antes de cada dígito, luego la cadena se mide evaly se multiplica con el producto actual.
En segundo lugar, $t-=64-ord for/\pl/g;sumas en $tcada letra ( for/\pl/g). ( orddevuelve el código ascii para la letra, y 64-..hace que esté entre 1 y 26.
Finalmente, $.==$tcomprueba que ambos valores son iguales y ($.**.5|0)**2!=$.que no es ni un cuadrado perfecto.

Python 2, 267 207 bytes

^{Guardado 60 bytes gracias a ovs}

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

Función con uso: print(g('A1B2C3'))

Pruébalo en línea!

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

Pruébalo en línea!

• ahorró 7 bytes gracias a Jonathan y Shooqie
• guardado 1 byte: También se solucionó el problema de falsos positivos. ¡Gracias a Jonathan por señalarlo!
• 11 bytes agregados: la edición anterior era incorrecta (la multiplicación de la suma de dígitos estaba ocurriendo en un bucle no deseado)

Retina, 143 bytes

Devuelve 1 para verdadero, 0 para falso

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

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

^ (1 *) \ n \ 1 $

Pruébalo en línea!

Explicación:

[1-9]
PS
10 | 01
1

Primero, reemplazamos todos los dígitos distintos de cero con su representación unaria. Eliminamos los ceros con un dígito adyacente para que no afecten nuestras operaciones unarias.

S_` (\ D)

Divida la cadena resultante en letras, teniendo cuidado de excluir líneas vacías (esto es un problema cuando dos letras son consecutivas AA).

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

Ordenar la cadena lexicográficamente. Luego, haga lo siguiente repetidamente:

1) Reemplace cada uno 1con el número de 1s en la siguiente línea (esto imita la multiplicación)

2) Eliminar la segunda línea de 1s

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

Reemplazar las letras J-Scon 1J, 1K, etc., y reemplazar las letras T-Zcon 2T, 2U, etc. A continuación, vuelva a colocar cada uno de los grupos A-I, J-Sy T-Zcon 1-9. Nos quedaremos con el valor numérico de cada letra (por ejemplo, 13para M).

1> `\ d + \ n?
PS

Convierta cada línea menos la primera en unaria (la primera línea ya está en unaria). Concatenar estas líneas. Ahora nos queda una cadena del formulario <product of digits>\n<sum of letters>.

^ ((? (1) ((? (2) \ 2 (11) | 111)) | 1)) * \ n

Reemplace un número cuadrado con la cadena vacía. Esto utiliza el método del "árbol de diferencias" .

^ (1 *) \ n \ 1 $

Regrese 1si las dos cuerdas a cada lado del \npartido. De lo contrario, regrese 0.