Inspirado en este CMC

Dado un entero positivo mayor que 0, realice la siguiente operación en él:

• Si los diez dígitos individuales ( 1234567890) están en el número al menos una vez, envíe la cuenta y salga del programa
• De lo contrario, duplique el número y repita, incrementando el conteo.

El recuento comienza en 0 y es el número de veces que se duplicó la entrada. Por ejemplo, si la entrada fuera 617283945, tendría que duplicarse una vez porque 1234567890 tiene los 10 dígitos.

Este es un código de golf, por lo que gana el código más corto. La entrada se puede tomar como una cadena, si lo desea.

Casos de prueba

input => output

617283945 => 1
2 => 67
66833 => 44
1234567890 => 0
100 => 51
42 => 55

Python 3 , 39 bytes

f=lambda n:len({*str(n)})<10and-~f(n*2)

Pruébalo en línea!

Salidas Falsepara 0.

J , 24 23 bytes

(]1&(+$:)2**)10>#@~.@":

Pruébalo en línea!

Explicación

(]1&(+$:)2**)10>#@~.@":  Input: integer n
                     ":  Format as string
                  ~.@    Unique
                #@       Length
             10>         Less than 10
           *             Multiply, gives n if previous was true, else 0
         2*              Multiply by 2
 ]                       Get the previous condition
  1&(   )                Execute this if true on 2n, else return 0
      $:                   Recurse
  1  +                     Add 1

05AB1E , 11 10 bytes

-1 byte gracias a scottinet

[D9ÝåË#·]N

Pruébalo en línea! o como un conjunto de pruebas

[          // Start infinity loop
 D         // Duplicate current value (or input)
  9Ý       // Push [0,1,2,3,4,5,6,7,8,9]
    å      // Does each exist in the current value
     Ë#    // Break if all equal (if every digit exists)
       ·   // Else double the current value
        ]N // End loop and print the number of times through the loop

Perl 6 ,31 28 bytes (27 caracteres)

-3 bytes gracias a @Joshua

{($_,2×*...*.comb.Set>9)-1}

Pruébalo en línea!

Explicación: sigue siendo la misma construcción para generar listas de forma recursiva. El primer elemento es el número dado ( $_), cada elemento siguiente es 2 veces el anterior ( 2×*- usamos ×, porque, aunque el carácter de 2 bytes, sigue siendo 1 byte más barato que 2 * *), y hacemos esto hasta que *.comb.unique>9se cumpla la condición final de , es decir, cuando hay más de 9 caracteres únicos en el número. (Técnicamente, desglosamos la cadena en una lista de caracteres con.comb , la forzamos a un conjunto con .Set(por supuesto, los Conjuntos contienen cada elemento solo una vez) y la comparamos con 9, lo que fuerza el conjunto en contexto numérico, lo que a su vez da su número de elementos)

Finalmente, restamos 1 de esta lista. Nuevamente, la lista se ve obligada a entrar en contexto numérico, por lo que lo que devolvemos es 1 menos que la longitud de esa lista.

JavaScript (ES6) + big.js , 84 74 73 70 bytes

Gracias @ ConorO'Brien por guardar 10 bytes sugiriendo big.js lugar de bignumber.js
Gracias a @Rick Hitchcock por -1 byte
Gracias a @Shaggy por -3 bytes

f=n=>[..."4"+2**29].every(d=>RegExp(d).test(c=Big(n)))?0:1+f(c.mul(2))

Toma la entrada como cadena; soporta hasta alrededor de 2 ⁶⁹ debido a la conversión automática de notación científica que se produce más allá de ese punto.

Fragmento de prueba

f=n=>[..."4"+2**29].every(d=>RegExp(d).test(c=Big(n)))?0:1+f(c.mul(2))

;[617283945, 2, 66833, 1234567890, 100, 42].forEach(t=>console.log(`f(${t}) = `+f(t)))

<script src="https://cdn.rawgit.com/MikeMcl/big.js/c6fadd08/big.min.js"></script>

Rango infinito, 106 88 87 84 bytes

Al usar la opción de configuración para deshabilitar efectivamente la notación científica al convertir números en cadenas, podemos tener un rango casi infinito.

f=n=>[..."4"+2**29].every(d=>RegExp(d).test(c=Big(n)),Big.E_POS=1e9)?0:1+f(c.mul(2))

let num = `${Math.random()*1e6|0}`.repeat(100)
O.innerText=`f(\n${num}\n) = ${f(num)}`

<script src="https://cdn.rawgit.com/MikeMcl/big.js/c6fadd08/big.min.js"></script>
<pre id=O style="width:100%;white-space:normal;overflow-wrap:break-word"></pre>

Gelatina , 12 , 11 bytes

QLn⁵
ḤÇпL’

Pruébalo en línea!

¡Tengo que ir rápido!

Explicación:

        # Helper link, takes one argument 'z'
Q       # The unique digits of 'z'
 L      # Length
  n     # Does not equal
   ⁵    # 10
        #
        # Main link
  п    # While <condition> is true, run <body> and return all intermediate results
        # Condition:
 Ç      #   The helper link
        # Body:
Ḥ       #   Double the input
        # Now we have a list of all the 'z's that we passed to the helper link
    L   # Return it's length
     ’  # minus one

Haskell , 46 bytes

f n|all(`elem`show n)['0'..'9']=0|1<3=1+f(2*n)

Pruébalo en línea!

J , 43 bytes

f=:(,$:@+:@{.)`[@.(9<[:#@~.10&#.inv)
<:@#@f

Pruébalo en línea!

Define una función anónima. Recoge resultados bastante subóptimamente. ¡Mira la respuesta superior de millas aquí!

Haskell, 44 bytes

until(\c->all(`elem`show(n*2^c))['0'..'9'])(+1)0

Clojure, 115 89 82 bytes

-26 bytes simplemente usando una cadena para representar la lista de caracteres (duh, en retrospectiva), y cambiando de usar recursión a loop, lo que me permitió hacer un par de optimizaciones.

-7 bytes al deshacerse de la llamada a bigint. Aparentemente solo necesitamos manejar la entrada que no causará un desbordamiento.

#(loop[n % c 0](if(empty?(remove(set(str n))"1234567890"))c(recur(* 2 n)(inc c))))

Pregolfed:

(defn pan [num]
  (loop [n num
         cnt 0]

    ; Remove all the characters from the stringified input
    ;  that are numeric. If the result is an empty list, all
    ;  the numbers were present.
    (if (empty? (remove (set (str n)) "1234567890"))
      cnt
      (recur (* 2 n) (inc cnt)))))

Retina , 85 bytes

^\d*
$&¶$&
D`.(?=.*¶)
\d{10}¶\d+|\d*¶

[5-9]
#$&
T`d`EE
T`_d#`d_`\d#
#
1
}`\d\b
$&@
@

Pruébalo en línea! El enlace incluye casos de prueba. Ligeramente optimizado para el tiempo de ejecución. Explicación:

^\d*
$&¶$&

Duplicar el número de entrada.

D`.(?=.*¶)

Deduplicar los dígitos en la primera copia.

\d{10}¶\d+|\d*¶

Si quedan 10 dígitos, elimine ambos números, de lo contrario simplemente elimine la primera copia. Tenga en cuenta que eliminar ambos números hace que el resto del ciclo no funcione.

[5-9]
#$&

Coloque un #antes de los dígitos grandes.

T`d`EE

Duplica cada dígito.

T`_d#`d_`\d#

Añadir en los acarreos.

#
1

Tratar con un llevar líder.

}`\d\b
$&@

Agregue un @bucle y hasta que se encuentren los 10 dígitos.

@

Imprime el número de @s agregados.

APL (Dyalog Unicode) , 19 + 2 = 21 bytes

0∘{∧/⎕D∊⍕⍵:⍺⋄⍺+1∇2×⍵}

Pruébalo en línea!

Este es un diádica Dfn( d directo teléfono f unctio n ), tomando 0 como su argumento izquierda y el número entero como la derecha. Como se supone que la entrada es solo el número entero, agregué 2 bytes para el argumento 0∘al recuento de bytes.

f←no está incluido en el recuento de bytes, ya que no es necesario . Simplemente hace que sea más fácil construir los casos de prueba.

Cómo funciona:

Los encabezados: los eliminé del conteo de bytes después de conversar en la sala de APL, ya que la función hace lo que se supone que debe hacer y los resultados solo son incorrectos debido a la configuración predeterminada de REPL de APL.

⎕FR←1287Establece la representación de F loat R en decimal de 128 bits (7 es el código para decimal en REPL de APL). ⎕PP←34Establece el P rint P recision a 34 dígitos. Ambos son necesarios, ya que la representación predeterminada de APL para números grandes los transforma en notación científica (por ejemplo, 3.14159265359E15) que desordenan el código a lo grande.

0∘{∧/⎕D∊⍕⍵:⍺⋄⍺+1∇2×⍵} ⍝ Dyadic Dfn
0∘                     ⍝ Fixes 0 as the left argument  
          :            ⍝ If
     ⎕D                ⍝ String representation of all digits [0, 9]
       ∊               ⍝ "is in"
        ⍕⍵             ⍝ String representation of the input
   ∧/                  ⍝ AND-reduction. Yields 1 (true) iff all digits are in the right argument.
           ⍺           ⍝ return the left argument
            ⋄          ⍝ Else
                 2×⍵   ⍝ Double the right arg
             ⍺+1       ⍝ increment the left arg
                ∇      ⍝ Recursively call this function with the new arguments.

Java 8, 132 110 87 74 bytes

n->{int c=0;for(;(n+"").chars().distinct().count()!=10;n*=2)c++;return c;}

-57 bytes gracias a @ OlivierGrégoire .

Explicación:

Pruébalo aquí. (Nota: el caso de prueba para 2está desactivado porque debería detenerse en 2 ⁶⁸ , pero el tamaño de longestá limitado a 2 ⁶³ -1.)

n->          // Method with long parameter and integer return-type
  int c=0;   //  Count-integer, starting at 0
  for(;(n+"").chars().distinct().count()!=10;
             //  Loop (1) as long as the unique amount of digits in the number are not 10
    n*=2)    //    After every iteration: multiply the input by 2
   c++;      //   Increase the count by 1
             //  End of loop (1) (implicit / single-line body)
  return c;  //  Return the counter
}            // End of method

La respuesta anterior de 132 bytes utiliza una Stringentrada y expresión regular:

n->f(n,0)int f(String n,int c){String t="";for(int i=0;i<10;t+="(?=.*"+i+++")");return n.matches(t+".*")?c:f(new Long(n)*2+"",c+1);}

Pruébalo aquí. (Nota: el caso de prueba para 2está deshabilitado porque causa una StackOverflowException debido a una recursión ligeramente excesiva).

La expresión regular total para verificar si la Cadena contiene los 9 dígitos se convierte en ^(?=.*0)(?=.*1)(?=.*2)(?=.*3)(?=.*4)(?=.*5)(?=.*6)(?=.*7)(?=.*8)(?=.*9).*$, que utiliza una anticipación positiva para toda la Cadena.

Casco , 10 bytes

←Vö>9Lud¡D

Pruébalo en línea!

Explicación

        ¡D    Repeatedly double the input, collecting results in a list
 V            Return the first index where the following is true
     L          The length of
       d        the digits
      u         with duplicates removed
  ö>9           is greater than 9
←             Decrement (as Husk uses 1-indexing)

Mathematica, 59 48 47 46 38 bytes

-9 bytes gracias a Jenny_mathy.

If[!FreeQ[DigitCount@#,0],#0[2#]+1,0]&

¡Pruébelo en línea usando Mathics!

R , 74 bytes

function(x){while(!all(0:9%in%el(strsplit(c(x,""),"")))){F=F+1;x=2*x};F*1}

Pruébalo en línea! Tenga en cuenta que R dará una respuesta incorrecta f(2)debido a las limitaciones de cómo el lenguaje almacena enteros grandes.

Explicación: Para la prueba de pandigitalidad, la entrada se coacciona a un vector de caracteres uniéndose con una cadena vacía y luego dividida en dígitos individuales. Luego verificamos si todos los 0: 9 están presentes en el vector resultante; si no, incrementamos el contador, duplicamos la entrada y repetimos.

El contador usa F que se inicializa como FALSO. Para asegurarnos de que sea forzado a numérico, multiplicamos por uno antes de regresar.

PowerShell , 70 69 bytes

for($n=[bigint]$args[0];([char[]]"$n"|group).count-le9;$n*=2){$i++}$i

Pruébalo en línea!

(Casi el doble de tiempo que la respuesta de Python: - \)

Toma datos $args[0], los convierte como a [bigint], los guarda en $n. Entra en un forbucle. Cada iteración verificamos si el número se $nconvierte en una cadena y luego en una charmatriz, cuando están Group-Objectjuntos, tiene un .count -less que o equal 9. Es decir, la única forma en que equivale a 10 es si al menos un dígito de cada número 1234567890está presente. En caso afirmativo, salimos del bucle. Si no, nosotros $n*=2y continuamos. Cada iteración dentro del bucle, simplemente estamos incrementando $i. Cuando salimos del bucle, simplemente salimos $i.

Tenga en cuenta que para entradas como 1234567890donde ya se tiene en cuenta cada dígito, esto no generará nada, que es un valor falso en PowerShell y equivalente a 0cuando se convierte como un [int]. Si eso no está bien, simplemente podemos poner un +frente a la salida $ipara convertirlo explícitamente en un entero.

Salvó un byte gracias a Roland Heath.

Pyth , 11 bytes

f>l{`.<QT9Z

Banco de pruebas .

Primer número natural Tdonde input << Tcumple el requisito.

Perl 5 , 52 + 1 (-p) = 53 bytes

$/=10;for$i(0..9){$/-=/$i/}$_*=2;++$\;$/&&redo}{$\--

Pruébalo en línea!

Perl, 43 + 1 bytes

for$x(0..9){$_*=2,++$\,redo LINE if!/$x/}}{

Usando la -pbandera. Esto se basa en la solución proporcionada por Xcali arriba.

Swift 4 , 111 bytes

func p(_ x:Int,_ c:Int=0)->Int{if !(String(Set(String(x)).sorted())=="0123456789"){return p(x*2,c+1)};return c}

Nota: No funcionará para x = 2, debido al desbordamiento.

Explicación: la entrada x se escribe primero en cadena. Luego Set () elimina los caracteres que se repiten. Luego se ordena para que coincida con el resultado. Si no coincide, x se duplica y el contador se incrementa.

Rubí, 46 45 39 38 bytes

def f n;n.digits.uniq[9]?0:1+f(n*2)end

Pruébalo en línea!

Actualizaciones:

1. -1 mediante el uso de en def f n;lugar de def f(n);.
2. -6 usando en …[9]lugar de….size==10
3. -1 quitando un punto y coma

Japt , 15 bytes

LÆ*2pXÃbì_â Ê¥A

Intentalo

Explicación

Entrada implícita de entero U.

LÆ    Ã

Crear una matriz de números enteros de 0a 99y pasar cada uno a través de una función donde Xes el elemento actual.

*2pX

Umultiplicado por 2 elevado al poder de X.

b

Obtenga el índice del primer elemento que devuelve verdadero cuando se pasa por la siguiente función.

ì_â

Dividir en una matriz de dígitos y eliminar los duplicados.

Ê¥A

Obtenga la longitud de la matriz y verifique la igualdad con 10.

Alternativa, 15 bytes

@*2pX)ìâ sÊ¥A}a

Intentalo

Explicación

Entrada implícita de entero U.

@            }a

Comenzando con 0, devuelve el primer número que devuelve verdadero cuando se pasa por la siguiente función, Xsiendo el número actual.

*2pX)

Como arriba, multiplique Upor 2 a la potencia de X.

ìâ

Dividir en una matriz de dígitos, eliminar duplicados y volver a unir a un número entero.

sÊ

Convierta en una cadena, obtenga la longitud y vuelva a convertir en un entero.

¥A

Verifique la igualdad con 10.

QBIC , 48 bytes, nc

{q=1[z|q=q*instr(!:$,!a-1$)]~q>0|_Xp\p=p+1┘b=b*2

Esto debería funcionar, en teoría. Sin embargo, en la práctica esto falla porque QBasic arroja números de diez dígitos (al menos necesarios para obtener todos los dígitos) a notación científica ... Debido a eso, lo he marcado como no competitivo.

Explicación

{             DO ad infinitum
q=1           set q to 1
[z|           FOR a = 1 to 10
q=q*instr     multiply q by the position
(!:$             - in 'b' (read from cmd line at start) cast to string (! ... $)
,!a-1$)          - of the number a-1 [0-9] cast to string
]             NEXT
~q>0          IF any character was not found, instr gave a 0. If q != 0 all digits were present
|_Xp          THEN quit, printing  p (is 0 at start)
\p=p+1        ELSE increase step counter p
┘b=b*2        and double 'b'

GNU dc, 61 bytes

La entrada se copia desde la parte superior de la pila (que de lo contrario debe estar vacía); la salida se empuja a la parte superior de la pila.

[I~1r:ad0<s]ss[d1+r;a1=p]sp[d2*lfx]sh[0Sadlsxlpx11!=h]dsfxz1-

Explicación

Usamos la variable de matriz a, almacenando un 1 a[d]si el dígito destá presente, de lo contrario volviendo a 0 allí. Usamos la extensión GNU ~para obtener el cociente y el resto en un solo comando.

# populate a[0-9] from the digits
[I~1r:ad0<s]ss

# check pandigit
# return 1 more than lowest unset element of a[]
# start with stack=0
[d1+r;a1=p]sp

# Test for pandigit; double and repeat if needed
[dd+lfx]sh
[0Sadlsxlpx11!=h]dsfx

# We left one value on the stack for each doubling, plus the original
z1-

Como beneficio adicional, esto funcionará en bases numéricas arbitrarias (no solo decimales): simplemente configure la raíz de entrada según sea necesario (la constante 11en la definición de fse leerá usando esa base numérica, por lo que es automáticamente correcta).

Prueba

for i in 617283945 2 66833 1234567890 100 42
do
    printf '%s => ' $i
    dc -e $i \
       -e '[I~1r:ad0<s]ss[d1+r;a1=p]sp[dd+lfx]sh[0Sadlsxlpx11!=h]dsfxz1-' \
       -e p
done

617283945 => 1
2 => 67
66833 => 44
1234567890 => 0
100 => 51
42 => 55

REXX, 57 bytes

arg n
do b=0 while verify(0123456789,n)>0
  n=n*2
  end
say b

q / kdb + , 33 bytes

Solución:

(#)1_{x*2 1 min!:[10]in 10 vs x}\

Ejemplos:

q)(#)1_{x*2 1 min!:[10]in 10 vs x}\[100]
51
q)(#)1_{x*2 1 min!:[10]in 10 vs x}\[1234567890]
0
q)(#)1_{x*2 1 min!:[10]in 10 vs x}\[42]
55

Explicación:

Todos los bytes están en la igualdad, podría ser capaz de jugar un poco más. Utiliza el scanadverbio de q :

count 1_{x*2 1 min til[10] in 10 vs x}\ / ungolfed solution
        {                            }\ / scan over this lambda until it yields same result
                              10 vs x   / convert to base 10
                           in           / left list in right list, returns boolean list
                   til[10]              / range 0..9
               min                      / return the minimum of the list, 0 or 1
           2 1                          / list (2;1) indexed into with 0 or 1
         x*                             / return x multiplied by either 2 or 1
      1_                                / 1 drop, drop one element from front of list
count                                   / count the length of the list

Notas:

Si pasamos al kindicador, entonces podemos tener una solución de 25 bytes. Convierte el número en una lista de caracteres:

q)\
  #1_{x*2 1@&/($!10)in$$x}\[100]
51