Escreva um programa para encontrar um número composto por 9 dígitos, no qual cada um dos dígitos de 1 a 9 aparece apenas uma vez. Esse número também deve atender a esses requisitos de divisibilidade:

1. O número deve ser divisível por 9.
2. Se o dígito mais à direita for removido, o número restante deverá ser divisível por 8.
3. Se o dígito mais à direita do novo número for removido, o número restante deverá ser divisível por 7.
4. E assim por diante, até que haja apenas um dígito (que será necessariamente divisível por 1).

Crédito Dávid Németh

CJam - 26

1{;9,:)_mrs0@{_3$<i\%+}/}g

É aleatório, mas funciona muito rápido com o interpretador java . Pode levar alguns minutos com o intérprete online .

Explicação:

1empurra 1 (a ser explicado mais adiante)
{…}gé um loop do-while
;remove um valor da pilha (inicialmente o 1 com o qual começamos)
9,faz com que o array [0 ... 8]
:)incremente os elementos do array, resultando em [1 ... 9]
_duplica o array
mrembaralha o array
sconverte em string
0@0 e depois coloca a outra cópia do array no topo
{…}/é um loop for-each (sobre os números 1 ... 9)
_duplica o número atual (vamos chamá-lo de "k" )
3$copia a sequência numérica da pilha
<iobtém a substring com os primeiros k caracteres, depois converte em
\%swaps inteiros com a outra cópia de k e obtém o restante (% k)
+adiciona o restante ao valor anterior na pilha (inicialmente 0 a partir de cima )
Neste ponto, temos a sequência numérica na pilha, seguida de um 0 se o número corresponder a todos os requisitos (ou seja, todos os restantes foram 0) ou um valor diferente de 0.
A parte superior da pilha se torna a condição de loop do-while. Ele é acionado e o loop continua se a condição for verdadeira.
Se encontrarmos a solução, a condição é 0 (false), o loop termina e o restante da pilha (a sequência numérica) é impressa.
Se não for a solução, a condição é o valor diferente de 0 (true) e o loop continua com a sequência na pilha. A string é exibida no início da próxima iteração (então o loop espera um valor na pilha, e esse é o motivo do 1 inicial).

Obrigado Dennis por tornar o código mais curto e complicado: p

Javascript (E6) 105 125 134

Construção recursiva do número, cada etapa verifica a divisibilidade.
Tempo de execução próximo a 0 s
Sem E / S neste momento, pois o OP solicitou que um programa localizasse o número, e o número é encontrado e registrado automaticamente no console

Golf mais Cortesia de MT0

(Q=(n,d,b)=>([(m=n+(s=[...b]).splice(i,1))%d||Q(m,d+1,s)for(i in b)],d>9&&(Q.z=n),Q.z))('',1,'123456789')

Golfe

(Q=(n='',d=1,b=[...'123456789'],i)=>{
for(i=0;s=[...b],m=n+s.splice(i,1),b[i];i++)m%d||Q(m,d+1,s);d>9&&(Q.z=n);return Q.z;
})()

Feio

(Q=(n='', d=1, b=[...'123456789'], i) => {
   for(i=0; s=[...b], m=n+s.splice(i,1), b[i]; i++)
     m % d || Q(m,d+1,s);
   d > 9 && (Q.z=n);
   return Q.z;
})()

Bônus

Com três pequenas alterações, você pode usar a mesma função para encontrar números mais longos usando a base> 10. Por exemplo, na base 14 ...

(Q=(n='',d=1,b=[...'123456789ABCD'],i)=>{
  for(i=0; s=[...b], m = n+s.splice(i,1), b[i]; i++)
    parseInt(m,14)%d || Q(m,d+1,s);
  d>13 && (Q.z=n);
  return Q.z;
})()

9C3A5476B812D

Ungolfed

Q=(n,d,b,i,c,z)=>{ // i,c,z fake parameters instead of vars.
  for (i=0; b[i]; i++)
  {
    s=[...b];
    m = n + s.splice(i,1);
    if (m % d == 0)
      if (z = d<9 ? Q(m, d+1, s) : m) return z;
  }
}
Q('',1,[...'123456789'])

Perl, 56

Uso: perl -E '...'

{$s++;redo if grep{$s!~$_||substr($s,0,$_)%$_}1..9}say$s

Resultado: 381654729

Este programa é realmente lento . Como em mais de 3,5 horas.

Como um exercício mais divertido, decidi desenvolver um algoritmo extremamente rápido:

my $set = [1..9];
for my $divisor (2..9) {
    my $newset = [];
    for my $element (@$set) {
        my $num = $element * 10;
        for (my $digit = $divisor - ($num % $divisor); $digit < 10; $digit += $divisor) {
            if (index($element, $digit) == -1) {
                push @$newset, $num + $digit;
            }
        }
    }
    $set = $newset;
}

print "@$set\n";

O procedimento acima é executado em 0,00095 segundos e confirma que há apenas uma solução para esse problema.

Python3, 214, 199, 184, 176, 174, 171, 165, 150146

from itertools import*
g=lambda i,d:d==1!=print(i)or int(i[9:])%d==0!=g(i[:-1],d-1)
for x in permutations("123456789"):g("".join(map(str,x))*2,9)

resultado:

381654729

Este é o meu primeiro roteiro de golfe. Espero que você goste :)

Pitão , 33 caracteres

=Y]kFkY~Yf>ql{TlT%vTlTm+k`dr1T)pk

Para testá-lo, coloque o código acima como entrada padrão no link no título.

Após compilar no Python 3.4:

k=''
T=10
Y=[k]
for k in Y:
 Y+=list(filter(lambda T:(len(set(T))==len(T))>(eval(T)%len(T)),
                map(lambda d:k+repr(d),range(1,T))))
print(k)

Explicação:

=Y]k:Y=['']

FkY: para k em F:

~Y: Adicionar a Y

f: Filtrar por

>ql{TlT: Todos os elementos exclusivos e

%vTlT: eval (elemento)% len (elemento) = 0

m+k` d Na lista de k + repr (d)

r1T: para d de 1 a 9.

): Fim do loop

pk: imprimir k

Ruby, 66 78 caracteres

[*r=1..9].permutation{|i|r.all?{|x|eval(i[0,x]*"")%x<1}&&$><<i*""}

O tempo de execução é de ~ 8 segundos (saída impressa após 3 s).

Isso não para depois de encontrar o primeiro número; portanto, tecnicamente, imprime todos os números que atendem aos critérios - mas, como existe apenas um número, não faz diferença.

Rubi 1.8, 63

[*r=1..9].permutation{|i|r.all?{|x|eval(i[0,x]*"")%x<1}&&$><<i}

Essencialmente a mesma solução acima. No Ruby 1.8, matrizes são convertidas em strings chamando-as implicitamente Array#join, para que possamos salvar a chamada para isso. Curiosamente, o código também roda muito mais rápido no Ruby 1.8 que 2.0 (tempo total de execução de 4,5 segundos, saída impressa após 1,6 s).

GolfScript (35 caracteres)

1,{{10*){.)}8*}%{`..&=},{.`,%!},}9*

Demonstração online

Isso cria prefixos que satisfazem a condição.

# Initial prefixes: [0]
1,
# Loop 9 times
{
    # Extend each prefix by digits 1 to 9
    {10*){.)}8*}%
    # Filter out ones which repeat a digit
    {`..&=},
    # Filter down to ones which are divisible by their length
    {.`,%!},
}9*

Haskell 129 121

Aqui está minha tentativa amadora de Haskell (sugestões / melhorias seriam muito apreciadas). Pode não ser o mais curto, mas é executado apenas.19 .65 segundos após as alterações de Flonk no meu sistema.

import Data.List;f=foldl1$(+).(*10);main=print$[f x|x<-permutations[1..9],f[mod(read.take y.show$f x)y|y<-[9,8..1]]<1]!!0

Javascript 75 (terminando)

Solução Bruteforce (super lenta)

for(a=c=1;b=c&&++a;)for(c=9;~(a+'').search(c)&&b%c<1;)--c?b=b/10|0:alert(a)

Se você deseja ver o resultado nesta vida útil, atualize o valor inicial para algo como a=c=38e7

Javascript 70 (sem terminação)

for(a=1;b=++a;)for(c=9;~(a+'').search(c)&&b%c<1;)--c?b=b/10|0:alert(a)

E apenas por diversão, uma força bruta aleatória que roda muito mais rápido: (somente ES6)

for(a=i=[..."123456789"];b=c=i&&a.sort(x=>Math.random()*9-5|0).join('');)for(i=9;c%i<1;)--i?c=c/10|0:alert(b)

Pitão, 142, 139, 125124

Essencialmente, o mesmo que a solução da @ Ventero, se eu entendi seu código corretamente, mas em Python (grande parte do crédito é para @Greg Hewgill).

from itertools import*;print[s for s in map(''.join,permutations('123456789'))if all(t(s[:i])%i==0 for i in range(1,9))][0]

Scala (128 caracteres)

Minha facada nisso ...

Seq(1,2,3,4,5,6,7,8,9).permutations.filter(p=>(2 to 8)forall{n=>(p.take(n).mkString.toLong%n==0)}).map(_.mkString.toLong).toList

Perl, 72

Uso: perl -M5.010 find-9-digits.pl

{$s=join'',sort{4-rand 8}1..9;redo if grep{substr($s,0,$_)%$_}2..9}say$s

Resultado: 381654729

Este programa está lento . Pode levar mais de 10 segundos, porque embaralha os dígitos "123456789", mas o embaralhamento tem uma falha.

Ungolfed:

# Enter a block.
{
     # Shuffle the characters "123456789".
     $s = join('', sort({2 - rand(4)} 1..9));

     # Redo block if any divisiblity test fails; grep returns the
     # number of failing tests.
     redo if grep({
        # For each divisor $_ in 2..9, test if the first $_ digits of
        # of $s are divisible by $_.  The test fails if the remainder
        # is a true value (not zero).
        substr($s, 0, $_) % $_
     } 2..9);
}
say $s;

Joguei o código que embaralha a matriz de dígitos 1..9:

• use List'Util shuffle;shuffle 1..9 (34 caracteres)
• sort{(-1,1)[rand 2]}1..9 (24 caracteres)
• sort{.5<=>rand}1..9 (19 caracteres)
• sort(2-rand 4}1..9 (18 caracteres)
• sort{4-rand 8}1..9 (18 caracteres)

O Perl espera que o bloco de classificação compare $ a e $ b de maneira consistente. Meus blocos de ordenação nunca mais olhar para $ a e $ b . Eles retornam uma ordem aleatória para que o tipo se torne um embaralhamento.

Se eu usasse sort{.5<=>rand}1..9, meu programa seria executado mais rapidamente. Esse compara 0,5 com uma flutuação aleatória de 0,0 a 1,0, excluindo 1,0, para uma chance de 1/2 que $ a <$ b , e uma chance de quase 1/2 que $ a> $ b . ( Cuidado: este é um "embaralhamento da Microsoft" , que não é um embaralhamento justo. Isso tem um viés porque .5<=>randnão fornece um pedido consistente.)

Suponha que eu jogue fora um personagem e use muito pior sort(2-rand 4}1..9. O Perl espera que o bloco de classificação retorne um número inteiro, mas 2-rand 4é um número flutuante. É uma flutuação aleatória de -2,0 a 2,0, excluindo -2,0. O Perl trunca esse flutuador em direção a zero, com estes resultados:

• 1/4 de chance de que $ a <$ b , número inteiro -1 de -2,0 <flutue <= -1,0
• quase 1/2 chance de que $ a == $ b , número inteiro 0 de -1,0 <flutuante <1,0
• quase 1/4 de chance de que $ a> $ b , inteiro 1 ou 2 de 1,0 <= float <= 2.0

Quando $ a == $ b , Perl não muda bem. Portanto, meu programa faria mais shuffles, até obter shuffles suficientes onde 2-rand 4não retornava 0 com muita frequência. Meu programa seria tão lento que pode levar mais de um minuto.

Eu uso sort{4-rand 8}1..9, então há apenas uma chance de 1/4 que $ a == $ b , e meu programa usa menos shuffles.

CJam, 35 bytes

0{)_`$A,1>s=!1$9,{9\m1$\%@+\A/}/;}g

Após aproximadamente 27 minutos, isso produz a seguinte saída:

381654729

Como funciona

0         " Push 0 (“n”).                                                      ";
{         "                                                                    ";
  )_`$    " Increment “N”, duplicate, stringify and sort the resulting string. ";
  A,1>s   " Push '123456789'.                                                  ";
  =!      " Push 0 if the strings are equal and 1 otherwise (“a”).             ";
  1$      " Copy “n”.                                                          ";
  9,{     " For each i in [ 0 1 2 3 4 5 6 7 8 ].                               ";
    9\m   " Calculate “9 - i”.                                                 ";
    1$\%  " Calculate “n % (9 - i)”.                                           ";
    @+    " Add the result to “a”.                                             ";
    \A/   " Swap “a” with “n” and calculate “n / 10”.                          ";
  }/      "                                                                    ";
  ;       " Discard “n”.                                                       ";
}g        " If “a > 0”, repeat the loop.                                       ";

Python 2 (78)

x=1
while len(set(`10*x`))<=9+sum(x/10**i%(9-i)for i in range(9)):x+=1
print x

Não há necessidade de gerar permutações, apenas tente cada número e verifique se seus dígitos mais 0 são distintos. Demora um pouco para correr.

SWI-Prolog 84

g([],O,_,O).
g(L,N,I,O):-nth1(_,L,D,R),M is N*10+D,J is I+1,0 is M mod J,g(R,M,J,O).

É um pouco enganador, porque a lista de dígitos precisa ser fornecida na consulta:

?- g([1,2,3,4,5,6,7,8,9],0,0,O).
O = 381654729 ;
false.

No entanto, é o que torna esse código interessante: você pode resolver o problema para qualquer lista de dígitos. Por exemplo:

?- g([1,2,3,4,5,6,7,8,9,0],0,0,O).
O = 3816547290 ;
false.

?- g([1,2,3,4,5,6,7,8],0,0,O).
O = 38165472 ;
false.

?- g([1,2,3,4,5,6,7],0,0,O).
false.

?- g([1,2,3,4,5,6],0,0,O).
O = 123654 ;
O = 321654 ;
false.

?- g([2,2,3,3,5,6,7,8,9],0,0,O).
O = 363258729 ;
O = 363258729 ;
O = 363258729 ;
O = 363258729 ;
O = 723258963 ;
O = 723258963 ;
O = 723258963 ;
O = 723258963 ;
false.

Python 2-114

Nem mesmo a menor solução Python, mas estou compartilhando assim mesmo:

e=""
f=lambda s,n:[[n,e.join(f(s.replace(j,e),n+j)for j in s)][s>e],e][n>e>0<int(n)%len(n)]
print f("123456789",e)

Bash + coreutils, 159 bytes

l=`echo {1..8}`
for d in {2..8};{
l=$(printf "a=%s;if(!a%%$d)a\n" $(eval echo {${l// /,}}{1..8}|tr \  '
'|grep -Pv '(\d).*\1')|bc|paste -d\  -s -)
}
echo ${l}9

Isso é meio longo, mas acho que o algoritmo é talvez um dos mais rápidos, considerando que este é um script de shell (geralmente lento) que roda em menos de 0,1 segundo.

O algoritmo é mais ou menos assim:

• Comece com o dígito mais à esquerda (1-8)
• acrescente o próximo dígito à direita (1-8)
• remova qualquer número com dígitos repetidos ( grep)
• verifique a divisibilidade por $d(o número do dígito) usandobc , com uma expressão gerada porprintf
• Repita o procedimento acima até que um número de 8 dígitos seja obtido

Observe que tomamos alguns atalhos, mas acho que estes são matematicamente sólidos:

• O dígito mais à esquerda deve ser divisível por 1, que é todos os dígitos, portanto, não verificamos explicitamente o primeiro conjunto de dígitos à esquerda
• O dígito mais à direita deve ser 9 (na verdade, não tenho certeza se essa é uma suposição válida - vou ter que pensar um pouco)

C ++, 187

Eu só tinha que tentar isso em C ++. Obviamente, não será a solução mais curta, mas aqui está:

#include <algorithm>
using namespace std;bool c(int n,int d=9){return d<2||n%d==0&c(n/10,d-1);}int main(){for(char n[]="123456789";next_permutation(n,n+9);)if(c(atoi(n)))return atoi(n);}

retorna o número em vez de imprimi-lo para salvar alguns caracteres (maldita incluir). Nos sistemas POSIX, é claro que isso será convertido em um sinal de 8 bits sem sinal e, portanto, não está correto - mas o programa calculará um número correto.

Ungolfed (requer C ++ 11):

#include <iostream>
#include <algorithm>
using namespace std;

bool check(int n, int digit = 9)
{
  return (n % digit==0) && (digit == 1 || check(n/10,digit-1));
}

int main()
{
  string num {"123456789"};
  while (next_permutation(begin(num), end(num)))
    if (check(stoi(num))){
      cout << num << endl;
      break;
    }
}

T-SQL 2005+ - 203

T-sql não é um idioma de golfe muito competitivo ...

with A(n)as(select top 10 number from spt_values where'p'=type),R as(select \r,1l union all select r*10+n,l+1from R,A where n not in(select substring(str(r),n,1)from A)and(r*10+n)%l=0)select max(r)FROM R

Deve ser executado no banco de dados mestre. Você pode substituir o primeiro CTE por isso para torná-lo independente de banco de dados, mas depois usa mais alguns caracteres (e requer 2008)

with A as(select*from(VALUES(1),(2),(3),(4),(5),(6),(7),(8),(9))f(n))

Formação legível:

 with A(n)as(select top 10 number from spt_values where'p'=type),
    R as(select \ r,1 l 
        union all 
        select r*10+n,l+1
        from R,A
        where n not in (
            select substring(str(r),n,1)
            from A
        )
        and(r*10+n)%l=0)
select max(r) FROM R

Basicamente, continuamos adicionando dígitos na parte de trás do rnúmero que ainda não vimos na string e certificando-nos de que a nova string ainda esteja no módulo 0 do nível atual. Inicializamos R para \, este é realmente o único truque neste código. O que é uma maneira louca de defini-lo como 0 no moneytipo de dados. Acho que é uma maneira de você digitar em \vez de moeda. $também faz a mesma coisa no T-SQL, mas $ltenta interpretar uma pseudo coluna que não existe e gera um erro. Isso evita a preocupação de usarinto que causaria um estouro normalmente na 10ª concatenação, forçando-nos a realmente verificar o nível. Edit: Curiosidade O T-sql, mesmo em 2014, não tem uma maneira integrada de transformar uma string em uma tabela de valores (por exemplo, nenhuma função dividida), então também podemos reutilizar nossa Atabela duas vezes para iterar os caracteres no R. restrito

As regras de precedência T-Sql são irritantes, portanto, temos que usar concatenação numérica (* 10 + n), em vez de concatenação de strings.

PHP, 89 bytes

versão aleatória, 89 bytes:

for($n=123456789;$n=str_shuffle($n);$d||die("$n"))for($d=10;--$d&&substr($n,0,$d)%$d<1;);

embaralha uma sequência contendo os dígitos e testa a divisibilidade em um loop.

Corra com -nr.

loop de força bruta, 90 bytes, muito lento:

for(;++$i<1e9;$d||die("$i"))for($d=10;--$d&&max(count_chars($i))<2&substr($i,0,$d)%$d<1;);

loops de 100000001, testa a divisibilidade no loop interno e sai quando encontra uma solução.

função recursiva, 94 bytes, muito rápido:

function f($n="",$e=1){while($d++<9)strpos(_.$n,"$d")|($x=$n.$d)%$e||print$e>8?$x:f($x,$e+1);}

acrescenta um dígito que ainda não está no número, se for dada a divisibilidade por comprimento, recursar (ou imprimir).

Isso explora que há apenas uma solução. sem isso, print$e>8?$x:f($x,$e+1)tinha que ser print$e>8?"$x\n":f($x,$e+1)(+3 bytes, imprimir todas as soluções) ou ($e>8?die("$x"):f($x,$e+1))(+4 bytes, sair na primeira solução) ou as soluções seriam impressas sem um delimitador.

Ligue com f();

-

TiO

A versão de força bruta não possui TiO por razões óbvias, mas você pode tentar as outras duas .

O tempo de execução da chamada de função é medido em linha (algo entre 2 e 4 milissegundos);
o tempo de execução total é medido pelo site (geralmente entre 50 e 500 ms).