Doblamiento Pandigital

14

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 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
caird coinheringaahing
fuente
¿Podemos tomar la entrada como una cadena?
Stephen
@Stephen puede tomar la entrada como una cadena.
caird coinheringaahing
3
¿Se garantiza que para alguno nexista algo kasí que nksea ​​pandigital? Me encantaría ver una prueba.
shooqie
1
@bfontaine Chat Mini Challenge
caird coinheringaahing
3
@shooqie Proof! Para cualquier n que sea coprime a 10, también es coprime a 10 ^ 10, por lo que existe algo de k tal que nk es 1 mod 10 ^ 10. Entonces 1234567890 * nk = 1234567890 mod 10 ^ 10, por lo que cada dígito necesariamente aparece al menos una vez. Si no, multiplique por 2, 5 o 25 según sea necesario para hacer el último coprimo de dígitos que no sea cero con 10, y una variante de la prueba anterior funciona (formalmente, n = 10 ^ m * p, donde p cumple la condición anterior , entonces 1234567890 * p * k como arriba es pandigital, entonces 1234567890 * p * k * 10 ^ m = 1234567890 * k * n es). :)
B. Mehta

Respuestas:

4

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
millas
fuente
Agradable. Estaba atrapado en la recopilación de los resultados, no pensé en usar ese tipo de función recursiva.
Conor O'Brien
4

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
Riley
fuente
-1 byte
scottinet
@scottinet ¡Gracias! No sé cómo me perdí eso.
Riley
@riley iba a decir use xpero eso también es 10 ... Buena respuesta. Se xeliminaría el pensamiento D, pero es la misma idea.
Magic Octopus Urn
3

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.

Ramillies
fuente
Puede usar en .Setlugar de .uniqueguardar 3 bytes.
Joshua
@Joshua, buen punto! Gracias. Nunca pensé en esto.
Ramillies
3

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 69 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.

Justin Mariner
fuente
¿Quizás podrías acortar el BigNumberbit usando big.js ?
Conor O'Brien
@ ConorO'Brien Eso definitivamente ayudará, especialmente porque newes opcional en ese. Se actualizará, gracias!
Justin Mariner
Ahorre un byte con f=n=>[..."0123456789"].every(d=>RegExp(d).test(c=Big(n)))?0:1+f(c.mul(2)).
Rick Hitchcock
No necesitamos manejar enteros grandes para que pueda soltar big.js si lo desea, reduciéndolo a 61 bytes. Y puede guardar 3 bytes reemplazando la cadena de dígitos con "4"+2**29: tio.run/##BcGxDkAwEADQb2GQO41LNBZDbX7AKgbhKkSu0jZSX1/…
Shaggy
2

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
DJMcMayhem
fuente
Test suite
caird coinheringaahing
2

Haskell, 44 bytes

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

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)))))
Carcigenicate
fuente
Puede guardar 7 bytes utilizando en every?lugar de empty? (remove …:#(loop[n % c 0](if(every?(set(str n))"1234567890")c(recur(* 2 n)(inc c)))))
bfontaine
@bfontaine ¡Oh, tienes razón! Gracias. Lo arreglaré más tarde. Gracias.
Carcigenicate
2

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.

Neil
fuente
2

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

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

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∊⍕⍵:⍺⋄⍺+12×⍵}  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.
J. Sallé
fuente
2

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 68 , pero el tamaño de longestá limitado a 2 63 -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.

Kevin Cruijssen
fuente
1
111 bytes (sí, el recuento de bytes es un "uni-digital" ;-)
Olivier Grégoire
Tenga en cuenta que 2 nunca funcionará porque esperamos 2^68como primer número pandigital, pero los largos en Java se limitan a 2^63-1.
Olivier Grégoire
1
87 bytes . Gracias reduce/
Olivier Grégoire
1
74 bytes . Parando aquí ;-)
Olivier Grégoire
1
@KevinCruijssen Sé que borró su método anterior, pero solo quiero señalar que puede usar la siguiente expresión regular para que coincida con los 10 dígitos:(?:.*?(\d)(?!.*\1)){10}
jaytea
1

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)
H.PWiz
fuente
1

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!

totalmente humano
fuente
2
46 bytes: If [Tr [1 ^ Union @ IntegerDigits @ #] <10, # 0 [2 #] + 1,0] &
J42161217
Mathematica permite funciones recursivas anónimas. :¡o gracias!
totalmente humano
2
38 bytes: If [! FreeQ [DigitCount @ #, 0], # 0 [2 #] + 1,0] &
J42161217
¡Oh gracias! Por cierto, `` se puede usar para el código pero no se permite el espacio en blanco inicial. afuncionará pero `a` no lo hará.
totalmente humano
seguro, por cierto, puedes usar este pie de página en TIO Print/@f/@{617283945,2,66833,1234567890,100,42}
J42161217
1

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.

usuario2390246
fuente
usar c(x,"")es un buen truco parael(strsplit(...))
Giuseppe
1

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.

AdmBorkBork
fuente
¿Podrías usar le9 en lugar de ne10? No estoy familiarizado con PowerShell, pero eso podría salvar un byte.
Roland Heath
@RolandHeath De hecho; buena llamada. ¡Gracias!
AdmBorkBork
0

Pyth , 11 bytes

f>l{`.<QT9Z

Banco de pruebas .

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

Monja permeable
fuente
0

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.


fuente
0

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.

Naresh
fuente
1
no funciona porque la var es de 64 bits. Hay muchas otras respuestas con el mismo problema.
Naresh
Si crees que esto debería permitirse, tráelo al OP. Puede ser una práctica común, pero el OP no lo ha permitido específicamente y los casos de prueba parecen sugerir que necesita apoyo 2.
Post Rock Garf Hunter
1
@FunkyComputerMan en realidad, permití respuestas que no pueden manejar números fuera de los límites del idioma, pero Shaggy parece haber eliminado el comentario al preguntar sobre eso. Esta respuesta esta bien.
caird coinheringaahing
0

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
bfontaine
fuente
0

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.

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

¥A

Verifique la igualdad con 10.

Lanudo
fuente
0

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'
Steenbergh
fuente
0

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
Toby Speight
fuente
0

REXX, 57 bytes

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

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
callejero
fuente