Dado un número real, conviértalo en una lista de listas, con el signo negativo (si lo hay) convirtiéndose en una lista vacía, la parte entera se convierte en una lista de dígitos y la parte fraccionaria (si la hay) en una lista de dígitos. Los dígitos deben ser números reales, no cadenas.

Ejemplos

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

Pruébalo en línea!

JavaScript (ES6), 33 44 43 41 bytes

Toma la entrada como una cadena. Se sacrificaron 11 10 bytes que convirtieron los elementos en la salida a números después de actualizar la especificación de desafío.

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

• Ahorré un byte gracias a la sugerencia de Arnauld de usar eval.

Pruébalo

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

Explicación

s=>

Función anónima que toma la cadena como argumento a través de un parámetro s.
"-123.45"

s.split(/\D/)

Use RegEx para dividir la cadena en una matriz en todos los caracteres que no sean dígitos, es decir, -y.
["","123","45"]

.map(a=>)

Asigne sobre la matriz, pasando cada cadena a una función a través de un parámetro a.

[...a]

Dividir en una serie de cadenas de caracteres individuales.
[[],["1","2","3"],["4","5"]]

.map(eval)

Asigne sobre el subconjunto y evalcada cadena, lo que lo convierte en un entero.
[[],[1,2,3],[4,5]]

Python 2 , 58 bytes

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

Pruébalo en línea!

Jalea ,  13  10 bytes

ŒṘµ<”/œpV€

Un enlace monádico que toma un número y devuelve la lista resultante de listas de números.

Pruébalo en línea! (el pie de página solo imprime la representación de Python para mostrar todas las listas reales)
... o vea el conjunto de pruebas .

¿Cómo?

ŒṘµ<”/œ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

Gracias a Riley por guardar un byte. Código:

'-'.:'.¡εSï

Utiliza la codificación 05AB1E . Pruébalo en línea!

Explicación:

'-'.:            # 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('.')]

Pruébalo en línea!

-5 bytes de Felipe Nardi Batista

Realmente , 23 bytes

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

Pruébalo en línea!

Explicación:

'.@;)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

Pruébalo aquí!

Salidas a la parte superior de la pila (porque SOGL lo convierte en una cadena multilínea porque está hecho para ascii-art). Para ver el resultado, busque en la consola después `r`@10:(los corchetes externos son las matrices de pila) o simplemente agregue οø∑después del 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

Toma la entrada como una cadena.

q\D ®¬®n

Pruébelo ( -Qmarque solo con fines de visualización).

• 2 bytes guardados gracias a Justin .
• 2 bytes guardados gracias a ETH.

Explicación

Entrada implícita de cadena U.

q\D

Use RegEx para dividir ( q) en una matriz en todos los caracteres que no sean dígitos.

®

Mapa sobre la matriz.

¬

Divida cada cadena en una matriz de caracteres individuales.

®

Mapa sobre la matriz.

n

Convierte a entero.

Octava , 54 bytes

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

Función anónima que toma un número como entrada y produce una matriz de celdas de vectores numéricos.

Pruébalo en línea!

Explicación

@(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

Debería poder jugar golf un poco ...

#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("]]");}

Pruébalo en línea!

Jalea , 12 bytes

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

Pruébalo en línea!

En realidad , 16 bytes

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

Pruébalo en línea!

Explicación:

$'.'-(Æ'.@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)

Estoy amando el RG biblioteca.

Tuve que agregar 26 bytes para asegurarme de que la lista vacía estaba realmente vacía.

               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

Salida de ejemplo:

> 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

Pruébalo en línea!

Se guardaron dos bytes debido a que Dom me recordaba $ &

Explicación:

$_="[[$_]]";        # 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

Pruébalo

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

Tenga en cuenta que …».combes una precedencia mayor que+«…

Python 2 , 59 bytes

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

Pruébalo en línea!

CJam , 13 bytes

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

Pruébalo en línea!

Pyth, 12 bytes

sMMcXz\-\.\.

Pruébalo aquí

Perl 6 , 22 bytes

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

Pruébalo en línea!

Los elementos en la lista devuelta son cadenas, pero como es normal para Perl, pueden usarse como números y se convertirán implícitamente; son "números reales" para todos los fines prácticos. Para obligarlos a ser números en su representación más inmediata, uno solo necesita prefijar el contenido del bloque de código con "+« "para tres bytes más.

RUBY, 75 bytes

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

Pruébalo en línea!