Not: Bu esinlenerek bu soruya @Willbeing görev belirli bir uzunlukta kusursuz plakaların sayısını saymak için, ama biraz farklı.

Metni aşağıdaki koşulları sağlayan plakaya mükemmel bir plaka diyoruz :

• Büyük harfler ( [A-Z]) veya rakamlar ( [0-9]) olabilen karakterlerden oluşur
• İngiliz alfabesinde harflerinin konumlarını toplayarak, 1 dizinli (yani A=1,B=2,...,Z=26:) bir tamsayı n verir
• Her basamak grubunu almak, toplamak ve ardından tüm sonuçları çarpmak aynı sonucu verir, n
• n mükemmel bir karedir (örneğin: 49 (7 ² ) , 16 (4 ² ) )

Bir neredeyse mükemmel plaka dışında mükemmel bir plaka için gerekli koşulları karşılayan n olan değil mükemmel bir kare.

Giriş

Plaka metnini temsil eden ve sabit kodlama haricinde herhangi bir standart biçimde girdi olarak alınan bir dize.

Çıktı

Verilen dize neredeyse mükemmel bir plakayı temsil ediyorsa, doğruluk değeri döndürün (örneğin: True/ 1), aksi takdirde yanlış bir değer döndürün (örneğin: False/ 0). Bu boşlukların kesinlikle yasak olduğunu dikkate alırken herhangi bir standart çıktı biçimi kabul edilir .

Örnekler

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!

puanlama

Bu kod golf , bu yüzden bayt en kısa cevap kazanır!

Jöle , 29 28 30 bayt

Bir hata düzeltmek için + 1 bayt için yanlış pozitif düzeltmek için + 1 bayt (yanlış sadece sıfırların altdizgelerin ilgili) ChristianSievers tarafından fark "0", "00"... (0 mükemmel bir kare) Yukarıdaki sabitleme sırasında bulunan.

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

Çevrimiçi deneyin! veya testleri çalıştırın

Nasıl?

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 bayt

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

MATL Online'da deneyin

açıklama

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

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)

Çevrimiçi deneyin!

Her karakteri base-36 ( h) içindeki bir sayı olarak yorumlar . Ondalık h>9biçime dönüştürür ve (bir harf anlamına gelir) toplamına ekler, aksi takdirde çalışan ürünü daha sonra oluşturmak için çarpılan bir değişkene ekler.

Perl 5 , 80 bayt

79 bayt kod + -pbayrak.

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

Çevrimiçi deneyin!

$.*=eval s/./+$&/gr for/\d+/g;ardışık basamakların toplamlarını çarpar. ( $.Başlangıç ​​değeri olduğu için kullanıyorum 1, yani çarpma için nötr bir elementtir). Daha kesin olarak, her bir basamak kümesi ( for/\d+/g) için, her bir basamağın önüne s/./+$&/gra yerleştirir +, ardından dize kullanılır evalve geçerli ürünle çarpılır.
İkinci olarak, her harf ( ) $t-=64-ord for/\pl/g;içindeki toplamlar . ( mektubun ascii kodunu döndürün ve 1 ile 26 arasında olmasını sağlar. Son olarak, her iki değerin aynı olduğunu ve ne mükemmel bir kare olup olmadığını kontrol eder .$tfor/\pl/gord64-..
$.==$t($.**.5|0)**2!=$.

Python 2, 267207 bayt

^{Ovs sayesinde 60 bayt kaydedildi}

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

Kullanım fonksiyonu: print(g('A1B2C3'))

Çevrimiçi deneyin!

Python 3 , 16315615516416416 bayt

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

Çevrimiçi deneyin!

• Jonathan ve Shooqie sayesinde 7 bayt tasarruf etti
• 1 bayt kaydedildi: Ayrıca yanlış pozitif sorun düzeltildi. Jonathan'a işaret ettiği için teşekkürler !
• 11 bayt eklendi: Önceki düzenleme yanlıştı (basamak toplamının çarpımı istenmeyen bir döngüde devam ediyordu)

Retina, 143 bayt

True için 1, false için 0 döndürür

[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 $

Çevrimiçi deneyin!

Açıklama:

[1-9]
, $ *
10 | 01
1

İlk olarak, sıfır olmayan tüm rakamları tekli gösterimleriyle değiştiriyoruz. Bitişik bir rakamla sıfırları kaldırırız, böylece tekli işlemlerimizi etkilemezler

S_` (\ D)

Boş satırları hariç tutmaya dikkat ederek sonuç dizesini harflere ayırın (iki harf ardışık olduğunda bu bir sorundur AA).

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

Dizeyi sözlükbilimsel olarak sıralayın. Ardından tekrar tekrar aşağıdakileri yapın:

1) Her birini aşağıdaki satırdaki s 1sayısıyla değiştirin 1(bu çarpmayı taklit eder)

2) ikinci satırı kaldır 1s

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

Harfleri değiştirin J-Sile 1J, 1Kvb harfleri yerine T-Zbirlikte 2T, 2Uvb Sonra grupların her yerini A-I, J-Sve T-Zile 1-9. Her harfin sayısal değeri ile bırakılacaktır (örn. 13İçin M).

1> '\ d +? \ N
, $ *

İlk satır hariç her satırı tekli olarak dönüştür (ilk satır zaten tekli). Bu satırları birleştirin. Artık formun bir dizesiyle kaldık <product of digits>\n<sum of letters>.

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

Kare bir sayıyı boş dizeyle değiştirin. Bu, "fark ağacı" yöntemini kullanır .

^ (1 *) \ n \ 1 $

Eşleşmenin 1her iki yanındaki iki tel varsa geri dönün \n. Aksi takdirde geri dönün 0.