Nota: questo si ispira a questa domanda di @Willbeing in cui il compito era contare il numero di piatti perfetti di una certa lunghezza, ma è leggermente diverso.

Chiamiamo una targa perfetta quella targa il cui testo soddisfa le seguenti condizioni:

• È composto da caratteri, che possono essere lettere maiuscole ( [A-Z]) o cifre ( [0-9])
• Sommando le posizioni delle sue lettere nell'alfabeto inglese, 1-indicizzato (cioè :) siA=1,B=2,...,Z=26 ottiene un numero intero n
• Ottenere ogni blocco di cifre, sommarle e quindi moltiplicare tutti i risultati produce lo stesso risultato, n
• n è un quadrato perfetto (ad esempio: 49 (7 ² ) , 16 (4 ² ) )

Una targa quasi perfetta soddisfa le condizioni per una targa perfetta, tranne per il fatto che n non è un quadrato perfetto.

Ingresso

Una stringa che rappresenta il testo della targa, presa come input in qualsiasi formato standard, ad eccezione dell'hardcoding.

Produzione

Se la stringa indicata rappresenta una targa quasi perfetta , restituisce un valore di verità (ad esempio: True/ 1), altrimenti restituisce un valore di falsa (ad esempio: False/ 0). È accettata qualsiasi forma standard di output, tenendo presente che queste scappatoie sono severamente vietate.

Esempi

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!

punteggio

Questo è code-golf , quindi vince la risposta più breve in byte!

Gelatina , 29 28 30 byte

+1 byte per correggere un errore notato da ChristianSievers (erroneamente trattare sottostringhe di soli zeri) +1 byte per fissare falsi positivi per "0", "00"... trovato durante sopra fissaggio (0 è un quadrato perfetto).

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

Provalo online! o eseguire test

Come?

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 byte

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

Provalo su MATL Online

Spiegazione

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

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)

Provalo online!

Interpreta ogni personaggio come un numero in base-36 ( h). Converte in decimale e aggiunge alla somma if h>9(che significa che è una lettera), altrimenti si aggiunge a una variabile che viene moltiplicata per formare il prodotto in esecuzione in un secondo momento.

Perl 5 , 80 byte

79 byte di codice + -pflag.

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

Provalo online!

$.*=eval s/./+$&/gr for/\d+/g;moltiplica le somme di cifre consecutive. (Sto usando $.perché il suo valore iniziale è 1, il che significa che è l'elemento neutro per la moltiplicazione). Più precisamente, per ogni blocco di cifre ( for/\d+/g), s/./+$&/grinserisce una +prima di ogni cifra, quindi la stringa viene evalattivata e moltiplicata per il prodotto corrente.
In secondo luogo, $t-=64-ord for/\pl/g;somma in $togni lettera ( for/\pl/g). ( ordrestituisce il codice ASCII per la lettera e lo 64-..rende compreso tra 1 e 26.
Infine, $.==$tverifica che entrambi i valori siano uguali e ($.**.5|0)**2!=$.che non sia né un quadrato perfetto.

Python 2, 267 207 byte

^{Risparmiato 60 byte grazie agli 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

Funzione con utilizzo: print(g('A1B2C3'))

Provalo online!

Python 3 , 163 156 155 164 161 byte

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

Provalo online!

• salvato 7 byte grazie a Jonathan e Shooqie
• salvato 1 byte: risolto anche il problema dei falsi positivi. Grazie a Jonathan per averlo segnalato!
• aggiunti 11 byte: la modifica precedente era errata (la moltiplicazione della somma delle cifre avveniva in un ciclo indesiderato)

Retina, 143 byte

Restituisce 1 per vero, 0 per falso

[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?
$ *
^ (((1) (((2) \ 2 (11) |?? 111)) | 1)) * \ n

^ (1 *) \ n \ 1 $

Provalo online!

Spiegazione:

[1-9]
$ *
10 | 01
1

Innanzitutto, sostituiamo tutte le cifre diverse da zero con la loro rappresentazione unaria. Rimuoviamo qualsiasi zero con una cifra adiacente in modo che non influenzino le nostre operazioni unarie

S_` (\ D)

Dividi la stringa risultante sulle lettere, facendo attenzione ad escludere le righe vuote (questo è un problema quando due lettere sono consecutive AA).

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

Ordina la stringa lessicograficamente. Quindi ripetere ripetutamente quanto segue:

1) Sostituisci ciascuno 1con il numero di 1s sulla riga seguente (imita la moltiplicazione)

2) Rimuovere la seconda riga di 1s

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

Sostituire le lettere J-Scon 1J, 1Ke così via e sostituire le lettere T-Zcon 2T, 2U, ecc Poi, sostituire ciascuno dei gruppi A-I, J-Se T-Zcon 1-9. Rimarremo con il valore numerico di ogni lettera (es. 13Per M).

1> `\ d + \ n?
$ *

Converti ogni riga tranne la prima in unaria (la prima riga è già in unaria). Concatena queste linee. Ora ci rimane una stringa del modulo <product of digits>\n<sum of letters>.

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

Sostituisci un numero quadrato con la stringa vuota. Questo utilizza il metodo "albero delle differenze" .

^ (1 *) \ n \ 1 $

Ritorna 1se le due stringhe su entrambi i lati della \npartita. Altrimenti, ritorna 0.