Dado um número real, converta-o em uma lista de listas, com o sinal negativo (se houver) se tornando uma lista vazia, a parte inteira se tornando uma lista de dígitos e a parte fracionária (se houver) se tornando uma lista de dígitos. Os dígitos devem ser números reais, não cadeias de caracteres.

Exemplos

0 → [[0]]

123 → [[1,2,3]]

-123 → [[],[1,2,3]]

123.45 → [[1,2,3],[4,5]]

0.45 → [[0],[4,5]]

-0.45 → [[],[0],[4,5]]

-123.45 → [[],[1,2,3],[4,5]]

C #, 60 66 bytes

using System.Linq;s=>s.Split('-','.').Select(p=>p.Select(c=>c-48))

Experimente online!

JavaScript (ES6), 33 44 43 41 bytes

Recebe a entrada como uma sequência. Sacrificou 11 10 bytes convertendo os elementos na saída em números após a atualização da especificação de desafio.

s=>s.split(/\D/).map(a=>[...a].map(eval))

• Salvei um byte graças à sugestão de Arnauld de usar eval.

Teste-o

console.log((
s=>s.split(/\D/).map(a=>[...a].map(eval))
)("-123.45"))

Explicação

s=>

Função anônima tomando a string como argumento via parâmetro s.
"-123.45"

s.split(/\D/)

Use RegEx para dividir a seqüência de caracteres em uma matriz em todos os caracteres que não sejam dígitos - ou seja, -e.
["","123","45"]

.map(a=>)

Mapeie o array, passando cada string para uma função via parâmetro a.

[...a]

Divida em uma matriz de seqüências de caracteres individuais.
[[],["1","2","3"],["4","5"]]

.map(eval)

Mapeie a sub-matriz e evalcada sequência, que a converte em um número inteiro.
[[],[1,2,3],[4,5]]

Python 2 , 58 bytes

lambda x:[map(int,i)for i in`x`.replace(*'-.').split('.')]

Experimente online!

Geléia ,  13  10 bytes

ŒṘµ<”/œpV€

Um link monádico que pega um número e retorna a lista resultante de listas de números.

Experimente online! (o rodapé apenas imprime a representação python para mostrar todas as listas reais)
... ou veja o suíte de testes .

Quão?

ŒṘµ<”/œpV€ - Link: number
ŒṘ         - Python representation (yields a string representation of the number)
  µ        - monadic chain separation (call that s)
    ”/     - literal '/' character
   <       - less than? (vectorises) ('.' and '-' are, digit characters are not)
      œp   - partition s at truthy indexes of the resulting list discarding the borders
        V€ - evaluate €ach (list of characters) as Jelly code (vectorises)

05AB1E , 12 11 bytes

Agradecemos a Riley por salvar um byte. Código:

'-'.:'.¡εSï

Usa a codificação 05AB1E . Experimente online!

Explicação:

'-'.:            # Replace "-" by "."
     '.¡         # Split on "."
        ε        # Apply to each element..
         S       #   Split into a list of characters
          ï      #   Convert back to int

Python 2 , 59 bytes

lambda a:[[]]*(a<0)+[map(int,n)for n in`abs(a)`.split('.')]

Experimente online!

-5 bytes de Felipe Nardi Batista

Na verdade , 23 bytes

'.@;)A$s⌠♂≈⌡M[[]]+@s~@t

Experimente online!

Explicação:

'.@;)A$s⌠♂≈⌡M[[]]+@s~@t
'.                       push "."
  @;)                    make a copy of the input and move it to the bottom of the stack
     A$s                 absolute value of input, stringify, split on periods
        ⌠♂≈⌡M            convert integer and fractional parts to lists of digits
             [[]]+       prepend an empty list
                  @s~    bitwise negation of sign of input (1 -> -2, 0 -> -1, -1 -> 0)
                     @t  elements in the list starting at that 0-based index (drops the leading empty list if the input was positive)

SOGL V0.12 , 11 bytes

Ζ-.ŗ .Θ⌡č¹r

Experimente aqui!

Saídas para o topo da pilha (porque SOGL a converte em uma sequência de múltiplas linhas porque é feita para ascii-art). Para visualizar o resultado, procure no console depois `r`@10:(os colchetes externos são as matrizes da pilha) ou apenas adicione οø∑após o código

Ζ-.ŗ         replace "-" with "."
     .Θ      split on "."s
       ⌡     for each
        č      chop into characters (casts to strings :/)
         ¹   wrap in array (this + for each is like map())
          r  reverse types, vectorizing

Japt (v2.0a0), 12 10 8 bytes

Recebe a entrada como uma sequência.

q\D ®¬®n

Teste-o ( -Qsinalize apenas para fins de visualização.)

• 2 bytes salvos graças ao Justin .
• 2 bytes salvos graças ao ETH.

Explicação

Entrada implícita da sequência U.

q\D

Use RegEx para dividir ( q) em uma matriz em todos os caracteres que não sejam dígitos.

®

Mapa sobre a matriz.

¬

Divida cada sequência em uma matriz de caracteres individuais.

®

Mapa sobre a matriz.

n

Converta em número inteiro.

Oitava , 54 bytes

@(x)cellfun(@(c){c-48},strsplit(num2str(x),{'-' '.'}))

Função anônima que recebe um número como entrada e produz uma matriz de células de vetores numéricos.

Experimente online!

Explicação

@(x)cellfun(@(c){c-48},strsplit(num2str(x),{'-' '.'}))

@(x)                                                    % Function with input x
                                num2str(x)              % Convert x to string
                       strsplit(          ,{'-' '.'})   % Split at '-' or '.'. Gives a
                                                        % cell array of substrings
    cellfun(          ,                               ) % To each substring apply
                                                        % the following function
            @(c){c-48}                                  % Subtract 48 from each char
                                                        % and pack into a cell

C (gcc) , 170 164 152 146 144 bytes

Deve ser capaz de jogar isso um pouco ...

#define P printf
#define V *v[1]
main(c,v)char**v;{for(V^45?P("[[%c",V++):P("[[],[%c",V++,V++);V;V^46?P(",%c",V++):P("],[%c",V++,V++));P("]]");}

Experimente online!

Gelatina , 12 bytes

ŒṘ⁾-.yṣ”.V€€

Experimente online!

Na verdade , 16 bytes

$'.'-(Æ'.@s⌠♂≈⌡M

Experimente online!

Explicação:

$'.'-(Æ'.@s⌠♂≈⌡M Implicit eval'd input
$                Convert to str
 '.              Push '.'
   '-            Push '-'
     (           Rotate stack left
      Æ          Pop a, b, c; push c.replace(b, a)
       '.        Push '.'
         @       Pop a, b; push b, a (swap)
          ⌠♂≈⌡   Push function ♂≈
           ♂       Map
            ≈        Convert to int
              M  Map

R, 51 47 72 bytes

x=RG::s(strtoi(s(gsub('-','.',scan()),on='\\.')))
x[is.na(x)]=list(NULL)

Estou amando a RGbiblioteca.

Foi necessário adicionar 26 bytes para garantir que a lista vazia estivesse realmente vazia.

               gsub('-','.',scan())             # replace - with . in input; also converts to string
             s(                    ,on='\\.')   # split string on '.'
      strtoi(                                )  # convert to numeric
RG::s(                                        ) # convert to lists of digits

    x[is.na(x)]=list(NULL)                      # converts list of `NA` to empty list

Exemplo de saída:

> x=RG::s(strtoi(s(gsub('-','.',-123.45),on='\\.')))
> x[is.na(x)]=list(NULL)
> x
[[1]]
NULL

[[2]]
[1] 1 2 3

[[3]]
[1] 4 5

Perl 5 , 56 54 + 1 (-p) = 55 bytes

$_="[[$_]]";s/\D\K\./0./;s/\d(?=\d)/$&,/g;s/-|\./],[/g

Experimente online!

Salvei dois bytes devido ao Dom me lembrar de $ &

Explicação:

$_="[[$_]]";        # Add opening and closing to ends of strings
s/\D\K\./0./;       # handle the case of .45 or -.45 by inserting 0 before
                    # the decimal.  Otherwise, .45 & 45 would be ambiguous.
s/\d(?=\d)/$&,/g;   # Put a comma between numbers.
s/-|\./],[/g        # Turn - and . into separators between lists

Perl 6 , 23 bytes

+«*.split(/\D/)».comb

Teste-o

Expandido

+«\            # numify each of the following (possibly in parallel)
*\             # WhateverCode lambda (this is the input)
.split(/\D/)\  # split on non-digits ( . and - )
».comb         # split each of those into individual characters

Observe que …».combé uma precedência mais alta que+«…

Python 2 , 59 bytes

lambda x:(x<0)*[[]]+[map(int,i)for i in`abs(x)`.split('.')]

Experimente online!

CJam , 13 bytes

r'-'.er'./::~

Experimente online!

Pitão, 12 bytes

sMMcXz\-\.\.

Experimente aqui.

Perl 6 , 22 bytes

{m:g/^\d*|\d+/».comb}

Experimente online!

Os elementos na lista retornada são cadeias de caracteres, mas como é normal para Perl, eles podem ser usados ​​como números e serão convertidos implicitamente; eles são "números reais" para todos os fins práticos. Para forçá-los a serem números em sua representação mais imediata, é necessário prefixar apenas o conteúdo do bloco de código com "+« "por mais três bytes.

RUBY, 75 bytes

->(x){(x<0?[[]]:[])+x.abs.to_s.split('.').map{|y|y.chars.map{|z|z.to_i}}}

Experimente online!