Introducción

En un chat privado, un amigo mío aparentemente se topó recientemente con un sistema de seguridad que tiene las siguientes dos restricciones en sus pines válidos:

• Cada dígito debe ser único (es decir, "1" solo puede aparecer una vez)
• El orden de los dígitos no importa ("1234" = "4321")

Entonces, para ilustrar cuán malo es este sistema de candado, ¡enumeremos todos los PIN válidos!

Entrada

Su entrada consistirá en un único número entero positivo, que denota la longitud del PIN.

Salida

Su salida consiste en una lista de enteros o cadenas * no negativos, que enumeran todos los PIN válidos de la longitud dada.

_{* Más precisamente, algo que un humano puede usar para probar todas las combinaciones si lo imprime para ellos. Esto significa que un conjunto de conjuntos de dígitos y conjuntos de conjuntos de dígitos están bien.}

¿Quién gana?

Este es el código de golf, por lo que gana la respuesta más corta en bytes. Se aplican reglas estándar y lagunas .

Casos de esquina

• El comportamiento de salida no está definido si se ingresa un entero mayor que 10.
• El orden de los dígitos dentro de cada entrada de salida no está definido, ya que las entradas con un cero realmente contienen dicho cero, es decir, no puede quitar "0123" a "123" pero "1230", "1203" y "1023" son válidos como es "0123".

Casos de prueba

1
[0,1,2,3,4,5,6,7,8,9]

2
[10,20,30,40,50,60,70,80,90,21,31,41,51,61,71,81,91,32,42,52,62,72,82,92,43,53,63,73,83,93,54,64,74,84,94,65,75,85,95,76,86,96,87,97,98]

3
[210,310,410,510,610,710,810,910,320,420,520,620,720,820,920,430,530,630,730,830,930,540,640,740,840,940,650,750,850,950,760,860,960,870,970,980,321,421,521,621,721,821,921,431,531,631,731,831,931,541,641,741,841,941,651,751,851,951,761,861,961,871,971,981,432,532,632,732,832,932,542,642,742,842,942,652,752,852,952,762,862,962,872,972,982,543,643,743,843,943,653,753,853,953,763,863,963,873,973,983,654,754,854,954,764,864,964,874,974,984,765,865,965,875,975,985,876,976,986,987]

4
[3210,4210,5210,6210,7210,8210,9210,4310,5310,6310,7310,8310,9310,5410,6410,7410,8410,9410,6510,7510,8510,9510,7610,8610,9610,8710,9710,9810,4320,5320,6320,7320,8320,9320,5420,6420,7420,8420,9420,6520,7520,8520,9520,7620,8620,9620,8720,9720,9820,5430,6430,7430,8430,9430,6530,7530,8530,9530,7630,8630,9630,8730,9730,9830,6540,7540,8540,9540,7640,8640,9640,8740,9740,9840,7650,8650,9650,8750,9750,9850,8760,9760,9860,9870,4321,5321,6321,7321,8321,9321,5421,6421,7421,8421,9421,6521,7521,8521,9521,7621,8621,9621,8721,9721,9821,5431,6431,7431,8431,9431,6531,7531,8531,9531,7631,8631,9631,8731,9731,9831,6541,7541,8541,9541,7641,8641,9641,8741,9741,9841,7651,8651,9651,8751,9751,9851,8761,9761,9861,9871,5432,6432,7432,8432,9432,6532,7532,8532,9532,7632,8632,9632,8732,9732,9832,6542,7542,8542,9542,7642,8642,9642,8742,9742,9842,7652,8652,9652,8752,9752,9852,8762,9762,9862,9872,6543,7543,8543,9543,7643,8643,9643,8743,9743,9843,7653,8653,9653,8753,9753,9853,8763,9763,9863,9873,7654,8654,9654,8754,9754,9854,8764,9764,9864,9874,8765,9765,9865,9875,9876]

Jalea , 4 bytes

ØDœc

Pruébalo en línea!

Explicación

ØDœc  Double-builtin; main link
  œc  Number of combinations of          of length
ØD                              [digits]
                                                   <right argument>

El comportamiento para n > 10es una lista vacía.

05AB1E , 5 bytes

žhæsù

Pruébalo en línea!

Explicación

   sù  # keep elements the length of the input
  æ    # from the powerset
žh     # of 0123456789

JavaScript (ES7), 89 bytes

Devuelve una lista de listas de dígitos (como caracteres) o una lista vacía si n> 10 .

n=>[...2**29+'4'].reduce((a,x)=>[...a,...a.map(y=>[x,...y])],[[]]).filter(a=>a.length==n)

Pruébalo en línea!

¿Cómo?

Primero generamos una lista de todos los dígitos decimales como caracteres calculando 2 ²⁹ = 536870912 , agregando el '4' que falta y dividiendo:

[...2**29+'4'] → [ '5', '3', '6', '8', '7', '0', '9', '1', '2', '4' ]

Luego calculamos el conjunto de potencia:

.reduce(                                   ,[[]]) // starting with a[] holding an empty list
        (a,x)=>[                          ]       // for each decimal digit x:
                ...a,                             //   copy all previous entries in a[]
                     ...a.map(y=>        )        //   and duplicate each previous entry y
                                 [x,...y]         //   with x prepended at the beginning

Finalmente, filtramos los resultados en su longitud:

.filter(a=>a.length==n)

Python 3 , 57 bytes

lambda l:combinations(range(10),l)
from itertools import*

Pruébalo en línea!

Encuentra todas las combinaciones 0 .. 9de longitudl .

El comportamiento para n > 10es una lista vacía.

Wolfram Language (Mathematica) , 22 bytes

0~Range~9~Subsets~{#}&

Pruébalo en línea!

Python 2 , 62 bytes

f=lambda n:{d+s for d in`5**19`*n for s in f(n-1)if d>s}or{''}

Devuelve un conjunto de cadenas.

Pruébalo en línea!

Pyth, 4 bytes

.cUT

Pruébalo aquí

Explicación

.cUT
  UT     [0, 1, ..., 9].
.c  Q    All (implicit input)-element subsets.

R , 17 bytes

combn(0:9,scan())

Pruébalo en línea!

Errores de entrada mayores que 10.

Devuelve un matrixdonde cada columna es un PIN.

Rubí , 30 bytes.

->n{[*[*0..9].combination(n)]}

Pruébalo en línea!

MATL , 6 bytes

4Y2wXN

Pruébalo en línea!

No devuelve nada (matriz vacía) para k>10.

          % implicit input k
4Y2       % push '0':'9'
   w      % swap top two elements of stack
    XN    % nchoosek, select all k-combinations of '0':'9' as a char array
          % implicit output

Haskell , 56 50 bytes

-6 bytes gracias a Hat Wizard .

(10!)
_!0=[[]]
w!n=[0..w-1]>>=(map.(:)<*>(!(n-1)))

Pruébalo en línea!

Java (JDK 10) , 105 bytes

n->{var s="";for(int i=1024,j;i-->0;s+=" ")for(j=10;n.bitCount(i)==n&j-->0;)s+=(1<<j&i)>0?j:"";return s;}

Pruébalo en línea!

Haskell , 47 bytes

f 0=[[]]
f n=[a:x|x<-f$n-1,a<-[0..9],all(/=a)x]

Pruébalo en línea!

Explicación

Cuando el número de dígitos es cero, solo hay una combinación, que es la vacía:

f 0=[[]]

Cuando el número de dígitos es ny n/=0las combinaciones son todas las formas de agregar dígitos a combinaciones de f$n-1tal manera que no se agrega ningún dígito a una combinación que ya lo contiene.

f n=[a:x|x<-f$n-1,a<-[0..9],all(/=a)x]

Gaia ,  4  3 bytes

₸…K

Pruébalo en línea!

¡Ha pasado un tiempo desde que publiqué una respuesta en Gaia! ¡Gracias al Sr. Xcoder por guardar un byte!

      % implicit input n
₸     % push 10
 …    % pop 10, push 0..9
  K   % all subsets of size n
      % print top of stack implicitly

Retina , 51 36 bytes

.+
10*
"$+"{%`^.
*_$&
L$v`_+
$.%`$%'

Pruébalo en línea! Salidas para nada n>10. Explicación:

.+
10*

Reemplace la entrada con 10 _s.

"$+"{

Repita el resto del programa. n tiempos del .

%`^.
*_$&

Prefije cada número con _ repetido según su primer dígito.

L$v`_+

Coincide con todos los _s, pero incluye todos los siguientes_ s en el partido, para lo cual debemos habilitar coincidencias superpuestas.

$.%`$%'

Para cada _ encontrado, prefije el número de _s a su izquierda al número.

Esto es un poco complicado, por lo que quizás un caso real sería mejor. Supongamos que ya hemos ejecutado el ciclo dos veces, de modo que se han generado todos los PIN de 2 dígitos, y actualmente estamos trabajando para crear PIN de 3 dígitos. Veremos qué sucede con 36: El primer dígito es 3, por lo tanto, tres _prefijos, para hacer ___36. Esto crea las siguientes coincidencias, marcadas aquí con `'s:

Match   $%` $.%`
`___'36     0
_`__'36 _   1
__`_'36 __  2

$%'evalúa 36en los tres casos, dando como resultado los PIN de 3 dígitos 036, 136y 236.

Si luego creáramos PIN de 4 dígitos, entonces 036no tendríamos ningún _prefijo y, por lo tanto, no habría coincidencias en la salida final.

Protón , 43 bytes

(0..9)&__import__("itertools").combinations

Pruébalo en línea!

Proton finalmente supera a Python: DI pensó (import itertools)que devolvería el valor, pero aparentemente fallé en eso. También importar *después no funciona porque no está en una lambda, es una expresión de nivel superior.

Japt, 5 bytes

Emite una matriz de matrices de dígitos. Emite todas las combinaciones si input es 0o una matriz vacía si input es <0o >10.

Ao àU

Intentalo

Explicación

          :Implicit input of integer U
A         :10
 o        :Range [0,10)
   àU     :Combinations of length U

Stax , 4 bytes

Vd,S

Pruébalo en línea!

Vdes "0123456789". ,empuja la entrada a la pila principal. Sobtiene combinaciones del tamaño especificado.

En el enlace tio, mse utiliza en el pie de página para imprimir cada salida.

ML estándar , 124 122 121 bytes

open List;fun f(s:: &)m=(if exists(fn x=>x=m)s then[]else[m::s])@f&m|f&m= &
fun!0=[[]]| !n=concat(tabulate(10,f(!(n-1))))

Pruébalo en línea! Ejemplo de uso: !2rendimientos[[0,1],[0,2],[0,3],[0,4],[0,5],[0,6],[0,7],[0,8],[0,9],[1,0],[1,2],[1,3], ...] .

Sin golf:

open List;

(* int list list -> int -> int list list *)
fun f (s::r) m =
    if exists (fn x => x=m) s 
    then f r m
    else (m::s) :: f r m
  | f [] m = []

(* int -> int list list *)
fun g 0 = [[]]
  | g n = concat(tabulate(10, f(g(n-1))))

Algunas alternativas:

125 123 bytes

fun f(s:: &)m=(if List.exists(fn x=>x=m)s then[]else[m::s])@f&m|f&m= &
fun!m 0=[[]]| !10n=[]| !m n=f(!0(n-1))m@ !(m+1)n;!0;

Pruébalo en línea!Define una función anónima a la que está vinculado it.

127 124 bytes

fun!0=[[]]| !n=let fun f(s:: &)m=(if List.exists(fn x=>x=m)s then[]else[m::s])@f&m|f&9=[]|f&m=f(!(n-1))(m+1)in f(!(n-1))0end

Pruébalo en línea!

JavaScript (Node.js) , 53 bytes

f=(i,b='',k=10)=>k--?f(i-1,k+b,k)+f(i,b,k):i?'':b+`,`

Pruébalo en línea!

Oracle 18 SQL, 169 bytes

No es un lenguaje de golf pero:

WITH t(v)AS(SELECT*FROM SYS.ODCINUMBERLIST(0,1,2,3,4,5,6,7,8,9)),n(a,b,c)AS(SELECT a,-1,''FROM i UNION ALL SELECT a-1,v,v||c FROM n,t WHERE v>b)SELECT c FROM n WHERE a=0

Se esperaba que la entrada estuviera en una tabla icon columna a:

CREATE TABLE i (a INT);
INSERT INTO i VALUES ( 3 );

Pruébelo en línea en Oracle Live SQL (se requiere un inicio de sesión gratuito y luego copie y pegue la solución en una hoja de trabajo) o SQLFiddle (sin inicio de sesión, pero requiere +7 bytes para funcionar en la versión inferior de Oracle).

CJam , 13 11 bytes

{Ae!f<:$_|}

Pruébalo en línea!

Técnicamente no se ejecuta en tio.run, ya que se agota el espacio de almacenamiento dinámico. Sin embargo, funciona correctamente para teclados de hasta 9 dígitos, y debería funcionar bien con más RAM.

Guardado 2 bytes gracias a Dennis

Bash , 113 99 bytes

p()(r $1 0 $[10-$1])
r()for i in `seq $2 $3`;{ (($1>1))&&r $[$1-1] $[i+1] $[$3+1] $4$i||echo $4$i;}

Pruébalo en línea!

JavaScript (Firefox 30-57), 67 bytes

n=>n?[for(x of f(n-1))for(y of Array(x?+x[0]:10).keys())y+x]:['']

El puerto de mi respuesta Retina, pero también funciona para n=0(devolver una lista de una cadena vacía, a diferencia de una lista vacía para n>10).

Carbón , 21 bytes

⊞υωＦχ≔⁺υＥυ⁺κＩιυΦυ⁼θＬι

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

⊞υω

Empuje la cadena vacía a la lista predefinida.

Ｆχ

Pase sobre cada dígito.

Ｅυ⁺κＩι

Agregue el dígito a cada cadena en la lista.

≔⁺υ...υ

Agregue el resultado a la lista original.

Φυ⁼θＬι

Imprima todas las cadenas con el número correcto de dígitos.

Perl 6 , 20 bytes

{combinations 10,$_}

Pruébalo en línea!

Esto es exactamente para qué sirve combinations(como una subrutina o .combinationsen una lista).

https://docs.perl6.org/routine/combinations

J , 32 bytes

.. frustrantemente más largo que Mathematica y R f=:{[:(#@>"0]/.])[:<@I.@#:@i.2^] TIO