Dato un numero intero non negativo o un elenco di cifre, determinare in quanti modi il numero può essere formato concatenando numeri quadrati, che possono avere zero iniziali.

Esempi

input -> output # explanation
164 -> 2 # [16, 4], [1, 64]
101 -> 2 # [1, 01], [1, 0, 1]
100 -> 3 # [100], [1, 00], [1, 0, 0]
1 -> 1 # [1]
0 -> 1 # [0]
164900 -> 9 # [1, 64, 9, 0, 0], [1, 64, 9, 00], [1, 64, 900], [16, 4, 900], [16, 4, 9, 0, 0], [16, 4, 9, 00], [16, 49, 0, 0], [16, 49, 00], [16, 4900]

Regole

• Si applicano scappatoie standard
• Questo è code-golf quindi vince la risposta più breve in byte

Haskell , 135 byte

s x=any((x==).(^2))[0..x]
c(a:b:x)=a*10+b:x
c x=x
h[x]=1>0
h x=(s.head)x
f x@(_:_:_)|y<-until h c x=f(tail y)+f(c y)
f x=sum[1|any s x]

Provalo online!

Probabilmente non è ancora ben golfato ma questo è un problema sorprendentemente difficile

Gelatina , 8 byte

ŒṖḌƲẠ€S

Un collegamento monadico che prende un elenco di cifre e restituisce un numero intero non negativo.

Provalo online! o vedi la suite di test .

Come?

ŒṖḌƲẠ€S - Link: list of digits              e.g. [4,0,0,4]
ŒṖ       - all partitions                         [[4,0,0,4],[4,0,[0,4]],[4,[0,0],4],[4,[0,0,4]],[[4,0],0,4],[[4,0],[0,4]],[[4,0,0],4],[4,0,0,4]]
  Ḍ      - convert from decimal list (vectorises) [[4,0,0,4],[4,0,   4 ],[4,    0,4],[4,      4],[   40,0,4],[   40,    4],[    400,4],     4004]
   Ʋ    - is square? (vectorises)                [[1,1,1,1],[1,1,   1 ],[1,    1,1],[1,      1],[    0,1,1],[    0,    1],[      1,1],        0]
     Ạ€  - all truthy? for €ach                   [        1,          1,          1,          1           0,            0,          1,        0]
       S - sum                                    5

Haskell , 88 byte

f x=sum[0.5|y<-mapM(\c->[[c],c:" "])x,all((`elem`map(^2)[0..read x]).read).words$id=<<y]

Definisce una funzione fche accetta una stringa e restituisce un float. Molto lento. Provalo online!

Spiegazione

Sto usando il mio suggerimento Haskell per calcolare tutte le partizioni di una stringa con mapMe words. Lo snippet mapM(\c->[[c],c:" "])xsostituisce ogni carattere 'c'di una stringa xcon la stringa di un elemento "c"o la stringa di due elementi "c "e restituisce l'elenco di tutte le possibili combinazioni. Se prendo uno dei risultati, ylo concateno e invoco wordsil risultato, verrà diviso negli spazi inseriti da mapM. In questo modo ottengo tutte le partizioni xin sottostringhe contigue. Quindi conto solo quei risultati in cui ogni elemento di partizione è un quadrato perfetto (trovandolo nell'elenco [0,1,4,9,..,x^2]). Un avvertimento è che ogni partizione viene contata due volte, con e senza uno spazio finale, quindi prendo la somma di0.5s invece di 1s; questo è il motivo per cui il tipo di risultato è float.

f x=                       -- Define f x as
 sum[0.5|                  -- the sum of 0.5 for
  y<-                      -- every y drawn from
  mapM(\c->[[c],c:" "])x,  -- this list (explained above)
                           -- (y is a list of one- and two-element strings)
  all(...)                 -- such that every element of
                 id=<<y]   -- concatenated y
          .words$          -- split at spaces satisfies this:
                           -- (the element is a string)
   (...).read              -- if we convert it to integer
    `elem`                 -- it is an element of
    map(^2)                -- the squares of
    [0..read x]            -- the numbers in this list.

Pyth , 16 byte

lf!f!sI@sjkY2T./

Suite di test .

Python 3 , 148 139 135 134 byte

10 byte grazie ad Arnold Palmer.

def f(a):
 s=[a[:1]]
 for i in a[1:]:s=sum([[x+[i],x[:-1]+[x[-1]*10+i]]for x in s],[])
 return sum({n**.5%1for n in x}=={0}for x in s)

Provalo online!

Mathematica, 141 byte

Count[FreeQ[IntegerQ/@Sqrt[FromDigits/@#],1<0]&/@(FoldPairList[TakeDrop,s,#]&/@Flatten[Permutations/@IntegerPartitions[Length[s=#]],1]),1>0]&

input (un elenco di cifre)

[{1,6,4}]

Python 2 , 173 163 byte

lambda s:len([l for l in[''.join(sum(zip(s,[','*(n>>i&1)for i in range(len(s))]+['']),())).split(',')for n in range(2**~-len(s))]if {int(x)**.5%1for x in l}=={0}])

Provalo online!

Modifica: salvato 10 byte grazie a ArnoldPalmer