Escriba un programa para encontrar un número que consta de 9 dígitos en el que cada uno de los dígitos del 1 al 9 aparece solo una vez. Este número también debe cumplir estos requisitos de divisibilidad:

1. El número debe ser divisible por 9.
2. Si se elimina el dígito más a la derecha, el número restante debe ser divisible por 8.
3. Si se elimina el dígito más a la derecha del nuevo número, el número restante debe ser divisible por 7.
4. Y así sucesivamente, hasta que solo haya un dígito (que necesariamente será divisible por 1).

Crédito Dávid Németh

CJam - 26

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

Es aleatorio pero funciona bastante rápido con el intérprete de Java . Puede tomar un par de minutos con el intérprete en línea .

Explicación:

1empuja 1 (que se explicará más adelante)
{…}ges un ciclo do-while
;elimina un valor de la pila (inicialmente el 1 con el que comenzamos)
9,hace que la matriz [0 ... 8]
:)incremente los elementos de la matriz, lo que resulta en [1 ... 9]
_duplica la matriz
mrbaraja, la matriz
sconvierte en cadena
0@empuja 0 y luego trae la otra copia de la matriz en la parte superior
{…}/es un bucle for-each (sobre los números 1 ... 9)
_duplica el número actual (vamos a llamarlo "k" )
3$copia la cadena numérica de la pila,
<iobtiene la subcadena con los primeros k caracteres, luego los convierte en
\%intercambios de enteros con la otra copia de k y luego obtiene el resto (% k)
+agrega el resto al valor anterior en la pila (inicialmente 0 desde arriba) )
En este punto, tenemos la cadena numérica en la pila, seguida de un 0 si el número coincide con todos los requisitos (es decir, todos los restantes fueron 0) o un valor distinto de 0 de lo contrario.
La parte superior de la pila se convierte en la condición de bucle do-while. Se abre y el bucle continúa si la condición era verdadera.
Si encontramos la solución, la condición es 0 (falso), el ciclo termina y se imprime el resto de la pila (la cadena numérica).
Si no es la solución, la condición es el valor distinto de 0 (verdadero) y el ciclo continúa con la cadena en la pila. La cadena aparece al comienzo de la siguiente iteración (por lo que el ciclo espera un valor en la pila, y esa es la razón del 1 inicial).

Gracias Dennis por hacer el código más corto y más complicado: p

Javascript (E6) 105125134

Construcción recursiva del número, cada paso verifica la divisibilidad.
Tiempo de ejecución cerca de 0 segundos
Sin E / S esta vez, ya que el OP solicitó un programa para encontrar el número, y el número se encuentra y se registra automáticamente en la consola

Golfed más Cortesía 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')

Golfed

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

Feo

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

Prima

Con 3 pequeños cambios, puede usar la misma función para encontrar números más largos usando base> 10. Por ejemplo, en 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

Sin golf

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

Salida: 381654729

Este programa es realmente lento . Como en más de 3.5 horas.

Como ejercicio más divertido, decidí desarrollar un algoritmo extremadamente 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";

Lo anterior se ejecuta en .00095 segundos y confirma que solo hay una solución para este 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)

salida:

381654729

Este es mi primer guión de golf. Espero que te guste :)

Pyth , 33 caracteres

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

Para probarlo, coloque el código anterior como entrada estándar en el enlace del título.

Después de compilar en 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)

Explicación:

=Y]k:Y=['']

FkY: para k en F:

~Y: Agregar a Y

f: Filtrado por

>ql{TlT: Todos los elementos únicos y

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

m+k` d En la lista de k + repr (d)

r1T: para d de 1 a 9.

): Fin del ciclo

pk: imprimir k

Rubí, 66 78 caracteres

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

El tiempo de ejecución es de ~ 8 segundos (salida impresa después de 3 s).

Esto no se detiene después de encontrar el primer número, por lo que técnicamente imprime todos los números que cumplen con los criterios, pero como solo hay uno de esos números, no hace la diferencia.

Rubí 1.8, 63

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

Esencialmente la misma solución que la anterior. En Ruby 1.8, las matrices se convierten en cadenas al invocarlas implícitamente Array#join, por lo que podemos guardar la llamada en eso. Curiosamente, el código también se ejecuta mucho más rápido en Ruby 1.8 que 2.0 (tiempo de ejecución total de 4.5 segundos, salida impresa después de 1.6 s).

GolfScript (35 caracteres)

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

Demostración en línea

Esto construye prefijos que satisfacen la condición.

# 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 129 121

Aquí está mi intento de Haskell aficionado (sugerencias / mejoras serían muy apreciadas). Puede que no sea el más corto, pero solo se ejecuta en.19 .65 segundos después de los cambios de Flonk en mi 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)

Solución de fuerza bruta (súper lenta)

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

Si desea ver el resultado en esta vida útil, actualice el valor inicial a algo como a=c=38e7

Javascript 70 (sin terminación)

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

Y solo por diversión, una fuerza bruta aleatoria que funciona mucho más rápido: (solo 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ón, 142, 139, 125124

Esencialmente igual que la solución de @ Ventero si entendí su código correctamente, pero en Python. (Gran parte del crédito va a @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)

Mi puñalada por esto ...

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

Salida: 381654729

Este programa es lento . Puede tomar más de 10 segundos, ya que baraja los dígitos "123456789", pero la barajadura tiene un defecto.

Sin golf:

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

Golfé el código que baraja la 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)

Perl espera que el bloque de clasificación compare $ a y $ b de manera consistente. Mis bloques de clasificación nunca miran $ a y $ b . Devuelven una ordenación aleatoria, por lo que la clasificación se convierte en un aleatorio.

Si lo usara sort{.5<=>rand}1..9, mi programa se ejecutaría más rápido. Ese compara 0.5 con un flotante aleatorio de 0.0 a 1.0, excluyendo 1.0, para una probabilidad de 1/2 de que $ a <$ b , y una probabilidad de casi 1/2 de que $ a> $ b . ( Cuidado: este es un "Microsoft shuffle" , que no es un shuffle justo. Esto tiene un sesgo porque .5<=>randno proporciona un orden consistente).

Supongamos que juego con un personaje y uso el peor sort(2-rand 4}1..9. Perl espera que el bloque de clasificación devuelva un número entero, pero 2-rand 4es flotante. Es un flotante aleatorio de -2.0 a 2.0, excluyendo -2.0. Perl trunca este flotador hacia cero, con estos resultados:

• 1/4 posibilidad de que $ a <$ b , entero -1 de -2.0 <flotante <= -1.0
• casi 1/2 probabilidad de que $ a == $ b , entero 0 desde -1.0 <flotante <1.0
• cerca de 1/4 de probabilidad de que $ a> $ b , entero 1 o 2 de 1.0 <= float <= 2.0

Cuando $ a == $ b , Perl no baraja bien. Entonces, mi programa haría más barajaduras, hasta que obtenga suficientes barajaduras en las 2-rand 4que no devuelva 0 con demasiada frecuencia. Mi programa correría tan lento que podría tomar más de un minuto.

Yo uso sort{4-rand 8}1..9, por lo que solo hay una probabilidad de 1/4 de que $ a == $ b , y mi programa usa menos barajaduras.

CJam, 35 bytes

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

Después de aproximadamente 27 minutos, esto produce el siguiente resultado:

381654729

Cómo 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.                                       ";

Pitón 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

No es necesario generar permutaciones, solo pruebe cada número y verifique si sus dígitos más 0 son distintos. Toma un tiempo 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).

Es un poco engañoso, porque la lista de dígitos debe ser proporcionada en la consulta:

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

Sin embargo, es lo que hace que este código sea interesante: puede resolver el problema para cualquier lista de dígitos. Por ejemplo:

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

Ni siquiera la solución Python más corta, pero la comparto de todos modos:

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

Esto es un poco largo, pero creo que el algoritmo es quizás uno de los más rápidos, teniendo en cuenta que este es un script de shell (generalmente lento) que se ejecuta en menos de 0.1 segundo.

El algoritmo va más o menos así:

• Comience con el dígito más a la izquierda (1-8)
• agregue el siguiente dígito a la derecha (1-8)
• eliminar cualquier número con dígitos repetidos ( grep)
• verifique la divisibilidad por $d(el número de dígito) usando bc, con una expresión generada porprintf
• Repita lo anterior hasta obtener un número de 8 dígitos.

Tenga en cuenta que tomamos un par de atajos, pero creo que estos son matemáticamente sólidos:

• El dígito más a la izquierda debe ser divisible por 1, que son todos dígitos, por lo que no verificamos explícitamente el primer conjunto de dígitos más a la izquierda
• El dígito más a la derecha debe ser 9 (en realidad no estoy seguro de si esta es una suposición válida, tendré que pensarlo un poco)

C ++, 187

Solo tenía que probar esto en C ++. Obviamente, no será la solución más corta, pero aquí 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);}

devuelve el número en lugar de imprimirlo para guardar algunos caracteres (maldita sea). En los sistemas POSIX, esto se convertirá, por supuesto, en un bit sin signo de 8 bits y, por lo tanto, no será correcto, pero el programa calculará un número correcto.

Sin golf (requiere 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 no es un lenguaje de golf muy 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

Debe ejecutarse en la base de datos maestra. Puede reemplazar el primer CTE con esto para que sea independiente de la base de datos, pero luego usa algunos caracteres más (y requiere 2008)

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

Formación legible:

 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

Básicamente, seguimos agregando dígitos al reverso del rnúmero que aún no hemos visto en la cadena, y nos aseguramos de que la nueva cadena siga siendo el módulo 0 del nivel actual. Inicializamos R a \, este es realmente el único truco en este código. Lo cual es una forma loca de establecerlo en 0 en el moneytipo de datos. Supongo que es una forma de permitirte escribir en \lugar de moneda. $también hace lo mismo en T-SQL, pero $lintentaría interpretar una pseudo columna que no existe y arrojará un error. Esto nos permite evitar la preocupación de usarintlo que causaría un desbordamiento normalmente en la décima concatenación, lo que nos obliga a verificar el nivel. Editar: Dato curioso T-sql, incluso en 2014, no tiene una forma integrada de convertir una cadena en una tabla de valores (por ejemplo, sin función dividida), por lo que en realidad también podemos reutilizar nuestra Atabla dos veces para iterar los caracteres en el R. stringified

Las reglas de precedencia de T-Sql son molestas, por lo que debemos utilizar la concatenación numérica (* 10 + n), en lugar de la concatenación de cadenas.

PHP, 89 bytes

versión aleatoria, 89 bytes:

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

baraja una cadena que contiene los dígitos, luego prueba la divisibilidad en un bucle.

Corre con -nr.

bucle de fuerza bruta, 90 bytes, muy lento:

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

bucles de 100000001, prueba la divisibilidad en el bucle interno y sale cuando encuentra una solución.

función recursiva, 94 bytes, muy rápida:

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

agrega un dígito que aún no está en el número, si se da la divisibilidad por longitud, recurse (o imprima).

Esto explota que solo hay una solución. sin eso, print$e>8?$x:f($x,$e+1)tenía que ser print$e>8?"$x\n":f($x,$e+1)(+3 bytes, imprimir todas las soluciones) o ($e>8?die("$x"):f($x,$e+1))(+4 bytes, salir en la primera solución) o las soluciones se imprimirían sin un delimitador.

Llamar con f();

-

TiO

La versión de fuerza bruta no tiene TiO por razones obvias, pero puedes probar las otras dos .

El tiempo de ejecución de la llamada de función se mide en línea (en algún lugar entre 2 y 4 milisegundos);
El sitio web mide el tiempo de ejecución total (generalmente entre 50 y 500 ms).