Número mágico de um determinado comprimento


13

Seu programa deve receber uma entrada ( npara fins de descrição) e gerar todas as permutações de um número de ndígitos longos sem dígitos repetidos, em que cada um dos dígitos anteriores e incluindo seu índice é divisível pelo local no número em que ele cai .

Você pode ler sobre números mágicos aqui .

Regras:

  • 1 <= n <= 10
  • Nenhum dígito pode ser repetido
  • O 0 inicial deve estar presente (se aplicável)
  • O primeiro ao xdécimo dígito do número (começando com o primeiro caractere como 1) deve ser divisível por x, ou seja, em 30685, 3é divisível por 1, 30é divisível por 2, 306é divisível por 2, é divisível por 3, 3068é divisível por 4 e 30685é divisível por 5 .
  • O programa deve usar um número inteiro como entrada (por meio da linha de comando, como argumento de função etc.) e imprimir todas as permutações que satisfazem as regras.
  • A saída deve ser separada por 1 ou mais caracteres de espaço em branco
  • As permutações podem começar e com zero (portanto, não são números tecnicamente mágicos).
  • A ordem de saída não importa
  • Você não precisa lidar com entrada inesperada
  • Vitórias menos caracteres em bytes

Exemplos

Dado 1:

0
1
2
3
4
5
6
7
8
9

Dado 2:

02
04
06
08
10
12
14
16
18
20
24
26
28
30
32
34
36
38
40
42
46
48
50
52
54
56
58
60
62
64
68
70
72
74
76
78
80
82
84
86
90
92
94
96
98

Dado 10:

3816547290

Agradecemos a Pizza Hut e John H. Conway pelo quebra-cabeça original (opção A). Obrigado a @Mego e @ sp3000 pelos links .



6
@DavisDude "Relacionado" não significa "duplicado". O objetivo de postar um link relacionado é que esse desafio seja exibido como "Vinculado" na barra lateral.
Martin Ender

1
Leitura relacionada: números
polidivisíveis

3
Os 0's iniciais precisam ser incluídos nos números de saída que os possuem?
Xnor

4
Você menciona impressão e espaço em branco quando se trata de saída, mas, para uma função, a forma mais natural de saída provavelmente retornaria uma lista. Isso é permitido?
Dennis

Respostas:


4

Geléia , 20 17 16 bytes

QḣQV%S
ØDṗçÐḟRj⁷

Isso é muito lento e consome muita memória ... Experimente online!

Como funciona

ØDṗçÐḟRj⁷  Main link. Input: n (integer)

ØD         Yield d := '0123456789'.
  ṗ        Compute the nth Cartesian power of d.
      R    Range; yield [1, ..., n].
    Ðḟ     Filter false; keep strings of digits for which the following yields 0.
   ç         Apply the helper link to each digit string and the range to the right.
       j⁷  Join the kept strings, separating by linefeeds.


QḣQḌ%S     Helper link. Arguments: s (digit string), r (range from 1 to n)

Q          Unique; deduplicate s.
 ḣ         Head; get the prefixes of length 1, ..., n or less.
           If s had duplicates, the final prefixes fill be equal to each other.
  Q        Unique; deduplicate the array of prefixes.
   V       Eval all prefixes.
    %      Compute the residues of the kth prefixes modulo k.
           If s and the array of prefixes have different lengths (i.e., if the
           digits are not unique), some right arguments of % won't have corr. left
           arguments. In this case, % is not applied, and the unaltered right
           argument is the (positive) result.
     S     Add all residues/indices. This sum is zero iff all digits are unique
           and the kth prefixes are divisible by k.

3
Se esta é lento ... a minha resposta é uma lesma sonolento
Luis Mendo

6

JavaScript (Firefox 30-57), 77 bytes

f=n=>n?[for(s of f(n-1))for(c of"0123456789")if(s.search(c)+(s+c)%n<0)s+c]:[""]

Editar: salvou 1 byte graças a @ edc65.


Uma jóia! Basta salvar 1 byte com...of"012...
edc65

@ edc65 Ugh, eu não acredito que ignorei isso.
5196 Neil

3

Pitão, 19 bytes

jf!s%VsM._TS;.PjkUT

Demonstração

Uma solução de força bruta. Explicação a seguir. Inspiração graças a FryAmTheEggman


22 bytes

juf!%sThH{I#sm+LdTGQ]k

Demonstração

Os números são criados e armazenados como seqüências de caracteres e convertidos apenas em ints para verificar a divisibilidade.

Explicação:

juf!%sThH{I#sm+LdTGQ]k
 u                 Q]k    Apply the following input many times, starting with ['']
             m    G       For each string at the previous step,
              +LdT        Append each digit to it
            s             Concatenate
         {I#              Filter out strings with repeats
  f                       Filter on
     sT                   The integer
    %  hH                 Mod the 1 indexed iteration number
   !                      Is zero.
j                         Join on newlines.

Estou curioso: quão masoquista você precisa ser para aprender Pyth? / s
DavisDude

2
@DavisDude Acho que é mais fácil do que aquilo que as pessoas pensam quando a veem. A parte mais assustadora está começando. Uma vez que você está dentro, você está dentro.
FliiFe

1
É bastante fácil, imho, por causa de quanto o modo de depuração ajuda você. Os documentos também são muito bons e explicam o que você precisa saber.
Ven

Apenas para referência, acabei com um mais usando ._e algumas outras coisas, mas é muuuito mais lento para grandes entradas:jjLkf!s.e%ib10hk._T.PUT
FryAmTheEggman

3

MATL , 30 bytes

4Y2Z^!"@Sd@!U10G:q^/kPG:\~h?@!

Experimente online!

Está muito lento. Pois input 3leva alguns segundos no compilador online. Para ver os números que aparecem um por um, inclua a Dno final do código .

Explicação

4Y2       % predefined literal: string '0123456789'
Z^        % implicit input. Cartesian power: 2D char array. Each number is a row
!         % transpose
"         % for each column
  @       %   push current column
  Sd      %   sort and compute consecutive differences (*)
  @!U     %   push current column. Convert to number
  10G:q^  %   array [1 10 100 ... 10^(n-1)], where n is the input
  /k      %   divide element-wise. Round down
  P       %   reverse array
  G:      %   array [1 2 ... n]
  \~      %   modulo operation, element-wise. Negate: gives 1 if divisible (**)
  h       %   concatenate (*) and (**). Truthy if all elements are nonzero
  ?       %   if so
    @!    %     current number as a row array of char (string)
          %   implicitly end if
          % implicitly end if
          % implicitly display stack contents

Algo está errado com seu código; Ele para de produzir saída para mim após 5 e, com 5, o último número (o único que eu me preocupei em verificar) está incorreto. 986 não é divisível por 3
DavisDude

Você está aqui:
Página Inicial

Eu acho que você não entendeu o aviso. Olhando para 3ver, você tem algumas indicações (por exemplo, 026). Além disso, uma explicação seria apreciada
DavisDude

Isso ainda não Work- 3 salta 021, 024, etc. O primeiro número correto é 063.
DavisDude

@DavisDude Editado, agora que li o desafio com mais cuidado #
Luis Mendo

1

Ruby, 87 bytes

Solução recursiva básica.

f=->n,x="",j=1{j>n ?puts(x):([*?0..?9]-x.chars).map{|i|f[n,x+i,j+1]if((x+i).to_i)%j<1}}

Se você puder retornar uma lista das permutações em vez de imprimir, 85 bytes:

f=->n,x="",j=1{j>n ?x:([*?0..?9]-x.chars).map{|i|f[n,x+i,j+1]if((x+i).to_i)%j<1}-[p]}

1

Python, 132 bytes

lambda n:[x for x in map(("{:0%s}"%n).format,(range(10**n)))if all(int(x[:i])%i<1and len(set(x))==len(x)for i in range(1,len(x)+1))]

Eliminou 26 bytes ao me livrar itertools, graças ao Sp3000 por me fazer perceber que não deveria usá-lo.

Eliminou 2 bytes usando a compreensão da lista em vez de filter, obrigado novamente ao Sp3000 pela dica.

Experimente on-line: Python 2 , Python 3

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.