A lista de PIN de cadeado exclusiva!

16

Introdução

Em um bate-papo particular, um amigo meu aparentemente tropeçou recentemente em um sistema de segurança que possui as duas restrições a seguir nos pinos válidos:

  • Cada dígito deve ser exclusivo ("1" pode aparecer apenas uma vez)
  • A ordem dos dígitos não importa ("1234" = "4321")

Então, para ilustrar o quão ruim é esse sistema de cadeados, vamos enumerar todos os PINs válidos!

Entrada

Sua entrada consistirá em um único número inteiro positivo, que indica o comprimento do PIN.

Resultado

Sua saída consiste em uma lista de números inteiros não negativos ou sequências *, que enumeram todos os PINs válidos do comprimento especificado.

* Mais precisamente, algo que um ser humano pode usar para experimentar todas as combinações, se você as imprimir. Isso significa que conjunto de conjuntos de dígitos e matrizes de matrizes de dígitos estão corretos.

Quem ganha?

Isso é código-golfe, então a resposta mais curta em bytes vence! Aplicam-se regras e brechas padrão .

Estojos de canto

  • O comportamento da saída é indefinido se um número inteiro maior que 10 for inserido.
  • A ordem dos dígitos em cada entrada de saída é indefinida, pois as entradas com zero realmente contêm o referido zero, ou seja, você não pode retirar de "0123" a "123", mas "1230", "1203" e "1023" são válidos como é "0123".

Casos de teste

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]
code-golf  combinatorics 
— SEJPM
fonte
1
A entrada não é negativa - portanto, na entrada zero, o programa deve ser uma lista contendo um valor, a sequência vazia?
— Aschepler
@aschepler de fato, o caso zero é quase tão sensato quanto o caso 11, então eu mudei para "número inteiro positivo".
— SEJPM

Respostas:

7

Gelatina , 4 bytes

ØDœc

Experimente online!

Explicação

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

Comportamento para n > 10 é lista vazia.

— HyperNeutrino
fonte
como ele não funciona com entradas maiores que 10 (tentei e me pareceu estranho)?
— Cookies de moinho de vento
2
@ gnu-ninguém dá a lista vazia porque você não pode ter uma combinação de 11 elementos com 10 opções.
— HyperNeutrino
ah, o ØD é o "0123456789". obrigado.
— Cookies de moinho de vento
6

05AB1E , 5 bytes

žhæsù

Experimente online!

Explicação

   sù  # keep elements the length of the input
  æ    # from the powerset
žh     # of 0123456789
— Emigna
fonte
Não sabia que ùera uma coisa. Tenho certeza que já usei filtro antes. Quão novo é esse?
— Magic Octopus Urn
1
@MagicOctopusUrn: Muito velho. Esteve lá por um longo tempo: P
— Emigna
Meu cérebro não vê o comando antes do agora. Meu cérebro não sou inteligente.
— Magic Octopus Urn
Já aconteceu comigo algumas vezes. Mais de uma vez em alguns comandos, bem, o que é ...
— Emigna
... aceitável para um nível divino 05AB1Er (05AB1E-ite? 05AB1E-an?) como você.
— Magic Octopus Urn
6

JavaScript (ES7), 89 bytes

Retorna uma lista de listas de dígitos (como caracteres) ou uma lista vazia se n> 10 .

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

Experimente online!

Quão?

Primeiro, geramos uma lista de todos os dígitos decimais como caracteres, calculando 2 29 = 536870912 , adicionando o número ausente '4' e dividindo:

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

Em seguida, calculamos o conjunto de potência:

.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

Por fim, filtramos os resultados em seu comprimento:

.filter(a=>a.length==n)
— Arnauld
fonte
3

Pitão, 4 bytes

.cUT

Experimente aqui

Explicação

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

MATL , 6 bytes

4Y2wXN

Experimente online!

Retorna nada (matriz vazia) 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
— Giuseppe
fonte
2

Haskell , 47 bytes

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

Experimente online!

Explicação

Quando o número de dígitos é zero, existe apenas uma combinação, ou seja, a vazia:

f 0=[[]]

Quando o número de dígitos é ne n/=0as combinações são todas as formas de adicionar dígitos a combinações, de f$n-1modo que nenhum dígito seja adicionado a uma combinação que já o contém.

f n=[a:x|x<-f$n-1,a<-[0..9],all(/=a)x]
— Post Rock Garf Hunter
fonte
2

Gaia ,  4  3 bytes

₸…K

Experimente online!

Já faz um tempo desde que eu postei uma resposta em Gaia! Obrigado ao Sr. Xcoder por salvar um byte!

      % implicit input n
₸     % push 10
 …    % pop 10, push 0..9
  K   % all subsets of size n
      % print top of stack implicitly
— Giuseppe
fonte
Você não precisa @.
— Xcoder
@ Mr.Xcoder obrigado. Não percebi isso; isso não parece estar documentado com muita clareza.
— Giuseppe
2

Retina , 51 36 bytes

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

Experimente online! Não produz nada para n>10. Explicação:

.+
10*

Substitua a entrada por 10 _s.

"$+"{

Repita o restante dos ntempos do programa .

%`^.
*_$&

Prefixe cada número com _repetido de acordo com seu primeiro dígito.

L$v`_+

Corresponda a todos os _s, mas inclua todos os seguintes _s na correspondência também, para os quais precisamos ativar correspondências sobrepostas.

$.%`$%'

Para cada _encontrado, prefixe o número de _s à esquerda do número.

Isso é um pouco complicado, então talvez um caso real seja melhor. Vamos supor que já executamos o loop duas vezes, para que todos os PINs de dois dígitos tenham sido gerados e, atualmente, estamos trabalhando neles para criar PINs de três dígitos. Veremos o que acontece com 36: O primeiro dígito é 3, portanto, três _s são prefixados, para serem criados ___36. Isso cria as seguintes correspondências, marcadas aqui com `'s:

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

$%'resulte em 36em todos os três casos, resultando nos pinos 3 dígitos 036, 136e236 .

Se formos criar PINs de quatro dígitos, 036não teremos nenhum _s como prefixo e, portanto, não resultará em nenhuma correspondência na saída final.

— Neil
fonte
A pergunta diz que a entrada não é negativa. Na entrada zero, isso gera dez caracteres sublinhados.
— Aschepler
@aschepler De fato; Vejo que o OP decidiu excluir esse caso, mas, no caso de você estar se perguntando, a correção seria anexada ^0e a um custo de 5 bytes.
— 187 Neil
1

Próton , 43 bytes

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

Experimente online!

Proton finalmente supera o Python: o DI pensou (import itertools)que retornaria o valor, mas aparentemente eu falhei nisso. A importação *posterior também não funciona porque não está em um lambda, é uma expressão de nível superior.

— HyperNeutrino
fonte
1

Japt, 5 bytes

Gera uma matriz de matrizes de dígitos. Produz todas as combinações se a entrada for 0ou uma matriz vazia se a entrada for <0ou >10.

Ao àU

Tente

Explicação

          :Implicit input of integer U
A         :10
 o        :Range [0,10)
   àU     :Combinations of length U
— Shaggy
fonte
Não acho que a saída para a entrada 0 esteja correta. A saída deve ser uma lista contendo um elemento que está vazio.
— Aschepler
@aschepler, de onde você está tirando isso?
— Shaggy
1

Stax , 4 bytes

Vd,S

Experimente online!

Vdé "0123456789". ,empurra a entrada para a pilha principal.Sobtém combinações do tamanho especificado.

No link tio, mé usado no rodapé para imprimir cada saída.

— recursivo
fonte
1

ML padrão , 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))))

Experimente online! Exemplo de uso: !2rendimentos [[0,1],[0,2],[0,3],[0,4],[0,5],[0,6],[0,7],[0,8],[0,9],[1,0],[1,2],[1,3], ...].

Ungolfed:

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

Algumas 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;

Experimente online! Define uma função anônima à qual 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

Experimente online!

— Laikoni
fonte
1

Oracle 18 SQL, 169 bytes

Não é um idioma de golfe, mas:

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

Esperava que a entrada estivesse em uma tabela icom coluna a:

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

Experimente online no Oracle Live SQL (é necessário um login gratuito e copie e cole a solução em uma planilha) ou SQLFiddle (sem login, mas requer +7 bytes para trabalhar na versão inferior do Oracle).

— MT0
fonte
1

CJam , 13 11 bytes

{Ae!f<:$_|}

Experimente online!

Tecnicamente, não é executado no tio.run, pois o espaço da pilha acaba. No entanto, ele funciona corretamente para teclados de até 9 dígitos e deve funcionar bem com mais RAM.

Economizou 2 bytes graças a Dennis

— maxb
fonte
0

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]:['']

Porta da minha resposta Retina, mas funciona n=0também (retornando uma lista de uma sequência vazia, diferente de uma lista vazia para n>10).

— Neil
fonte
0

Carvão , 21 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

⊞υω

Envie a sequência vazia para a lista predefinida.

Ｆχ

Faça um loop sobre cada dígito.

Ｅυ⁺κＩι

Anexe o dígito a todas as strings da lista.

≔⁺υ...υ

Anexe o resultado à lista original.

Φυ⁼θＬι

Imprima todas as strings com o número correto de dígitos.

— Neil
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.