Todas las combinaciones binarias a decimal


12

Descargo de responsabilidad

Esta pregunta no es un duplicado de esta pregunta . No estoy contando dígitos específicos, ya que los tenemos establecidos en los parámetros iniciales. Esta pregunta se centra en los números decimales que se pueden construir a partir de las cadenas binarias en función de los dígitos proporcionados.

Desafío

Dados dos enteros Xy Y, representando el número de ceros ( 0) y unos ( 1) respectivamente, calcule todos los equivalentes decimales posibles que se pueden determinar a partir de la creación de cadenas binarias usando solo los ceros y unos proporcionados, y los muestra como salida.

Ejemplo 1:

Entrada: 0 1

Salida: 1

Explicación: Solo uno 1para tener en cuenta, que solo se puede convertir de una manera.

Ejemplo 2

Entrada: 1 1

Salida: 1,2

Explicación: 01convierte a 1, 10convierte a 2.

Ejemplo 3

Entrada: 3 2

Salida: 3,5,6,9,10,12,17,18,20,24

Explicación: Tres 0sy dos 1s hacen 00011(3), 00101(5), 00110(6), 01001(9), 01010(10), 01100(12), 10001(17), 10010(18), 10100(20), 11000(24)

Limitaciones y Reglas

  • Solo esperaré que su código funcione donde 0 < X + Y <= 16el número máximo en la salida solo puede ocurrir a partir de 16 1s, es decir, parámetros 0y 16.
  • Como resultado de la limitación anterior, el rango de números que esperaríamos en la salida es de 0y 65535.
  • Aceptaré funciones o código, siempre que se proporcione la salida resultante, ya sea una lista separada por comas, una matriz, una lista enviada a STDOUT, etc. El único criterio que debo enfatizar sobre la salida es que debe ordenarse.
  • Este es el código de golf, los bytes mínimos recibirán la máxima gloria.
  • No toleraremos lagunas tontas

1
¿La salida tiene que ser ordenada?
Dennis

Hola @Dennis, sí, olvidé mencionar que ... la salida debe estar ordenada. He actualizado las reglas en consecuencia.
WallyWest

2
¿Necesitamos manejar el caso 0 0?
ETHproductions

@ETHproductions mencioné anteriormente eso 0 <= X + Y <= 16, así que sí, porque 0 0se consideraría una entrada válida que satisface esa regla.
WallyWest

2
En ese caso, ¿cuál es el resultado esperado 0 0? El número 0 puede representarse por cero, uno o más ceros.
Dennis

Respuestas:


5

Jalea , 8 bytes

0,1xŒ!ḄQ

Pruébalo en línea!

Cómo funciona

0,1xŒ!ḄQ Main link. Argument: [x, y]

0,1x     Repeat 0 x times and 1 y times.
    Œ!   Compute all permutations of the result.
      Ḅ   Unbinary; convert each permutation from base 2 to integer.
       Q  Unique; deduplicate the results.

Esto es bastante impresionante ... ¿Hay mucha demanda de J en el mercado de programación general? Me di cuenta de que Jelly se basa en eso?
WallyWest

1
Tiene una base de usuarios en algunas aplicaciones específicas (principalmente matemáticas / estadísticas), pero honestamente no lo sé. No he usado J fuera del código golf.
Dennis

@WallyWest No se solicita con frecuencia porque es el más adecuado para un entorno que se beneficiaría de la programación funcional. Por lo general, solo para programación muy especializada.
Conor O'Brien

7

Python, 60 bytes

lambda x,y:[n for n in range(1<<x+y)if bin(n).count('1')==y]

Pruébelo en Ideone .

Cómo funciona

Todos los números positivos que pueden representarse en binario con x ceros e y son claramente menores que 2 x + y , ya que la representación binaria canónica de este último tiene x + y + 1 dígitos.

La lambda simplemente itera sobre los enteros en [0, 2 x + y ) y mantiene todos los enteros n en ese rango que tienen y unos. Como n <2 x + y se puede representar con x (o menos) ceros.


5

Mathematica, 59 57 bytes

Un resultado habitual con Mathematica: funciones de alto nivel = bueno, nombres largos de función = malo.

#+##&~Fold~#&/@Permutations@Join[0&~Array~#,1&~Array~#2]&

Join[0&~Array~#,1&~Array~#2]crea una lista con el número correcto de 0s y 1s. Permutationsgenera todas las permutaciones de esa lista, sin repeticiones (como aprendí) y en orden ordenado. #+##&~Fold~#(una versión de golfuscated #~FromDigits~2) convierte una lista de dígitos de base 2 en el entero que representan.

Versión anterior, antes del comentario de Martin Ender:

#~FromDigits~2&/@Permutations@Join[0&~Array~#,1&~Array~#2]&

1
Sin embargo, bien observado y documentado ... Mathematica es excelente para el cálculo de números, no tan bueno para el golf de código ... bueno, algunas veces ...
WallyWest

1
FromDigitsgeneralmente se puede acortar:#+##&~Fold~#&/@Permutations...
Martin Ender

@ MartinEnder: ¡Lo entiendo! y vea cómo generalizar a otras bases también. Gracias por enseñarme este modismo inteligente.
Greg Martin

1
Los créditos para inventarlo van a alephalpha . ;)
Martin Ender

1
Resulta que cambiar al enfoque de Dennis es más corto:Select[Range[2^+##]-1,x=#;DigitCount[#,2,1]==x&]&
Martin Ender

5

CJam ( 15 14 bytes)

{As.*s:~e!2fb}

Este es un bloque anónimo (función) que toma la entrada como una matriz [number-of-ones number-of-zeros]y devuelve la salida como una matriz.

Demostración en línea


Un largo camino fuera de la marca, pero más interesante : esto es sin construcciones de permutación o conversión de base:

{2\f#~1$*:X;[({___~)&_2$+@1$^4/@/|_X<}g;]}

Funcionaría bien a medida que se desarrolla un GolfScript.


Yo estaba tratando de reemplazar el ee{)*}/con algo usando .*y se acercó con esta solución de 14 bytes: {As.*s:~e!2fb}El s:~parece un poco ineficiente aunque ahora.
Martin Ender

1
@ MartinEnder, en realidad comencé .*y decidí que eeera mejor que, por ejemplo 2,:a.*e_. Sin embargo, no me di cuenta de que e!eso dará el mismo resultado independientemente del orden de su argumento.
Peter Taylor


4

Japt , 16 bytes

'0pU +'1pV)á mn2

¡Pruébalo en línea!

Cómo funciona

                  // Implicit: U = first integer, V = second integer
'0pU              // Repeat the string "0" U times.
     +'1pV)       // Concatenate with the string "1" repeated V times.
           á      // Take all unique permutations.
             mn2  // Interpret each item in the resulting array as a binary number.
                  // Implicit: output last expression

Versión alternativa, 17 bytes.

2pU+V o f_¤è'1 ¥V
                   // Implicit: U = first integer, V = second integer
2pU+V              // Take 2 to the power of U + V.
      o            // Create the range [0, 2^(U+V)).
        f_         // Filter to only items where
           è'1     //  the number of "1"s in
          ¤        //  its binary representation
               ¥V  //  is equal to V. 
                   // Implicit: output last expression

He estado tratando de seguir jugando golf en ambas versiones, pero no puedo encontrar ninguna holgura ...


Esto se ve increíble ... ¡y funciona muy bien! ¿Sin embargo, el intérprete no muestra el código transpilado a la derecha? Me encantaría ver cómo se presenta.
WallyWest

@WallyWest Transpila aproximadamente a ("0".p(U)+"1".p(V)).á().m("n",2); cada una de las .x()funciones se define en el archivo fuente .
ETHproductions

3

Ruby, 63 bytes

Una implementación simple. Sugerencias de golf bienvenidas.

->a,b{(?0*a+?1*b).chars.permutation.map{|b|(b*'').to_i 2}.uniq}

No golfista

def f(a,b)
  str = "0"*a+"1"*b                   # make the string of 0s and 1s
  all_perms = str.chars.permutation   # generate all permutations of the 0s and 1s
  result = []
  all_perms.do each |bin|             # map over all of the permutations
    bin = bin * ''                    # join bin together
    result << bin.to_i(2)             # convert to decimal and append
  end
  return result.uniq                  # uniquify the result and return
end

3

Pyth - 11 bytes

{iR2.psmVU2

Test Suite .

{                Uniquify
 iR2             Map i2, which converts from binary to decimal
  .p             All permutations
   s             Concatenate list
    mV           Vectorized map, which in this case is repeat
     U2          0, 1
     (Q)         Implicit input

2

Python 2 - 105 99 bytes

+8 bytes porque nuestra salida necesita ser ordenada

lambda x,y:sorted(set(int("".join(z),2)for z in __import__('itertools').permutations("0"*x+"1"*y)))

Edición impresionante!
WallyWest

1
Gracias, no tenía idea de que podría importar módulos en funciones lambda.
Jeremy

Siempre pensé que se le permitía tener una declaración de importación por separado a los efectos del código golf. (Obviamente, aún necesita incluir su longitud). ¿Esto podría ahorrarle un byte o dos?
Neil

2

Mathematica, 47 bytes

Cases[Range[2^+##]-1,x_/;DigitCount[x,2,1]==#]&

Una función sin nombre que toma dos argumentos: número de 1s, número de 0s.

Esencialmente un puerto de la solución Python de Dennis . Creamos un rango desde 0hasta y luego mantenemos solo aquellos números cuya cantidad de bits es igual a la primera entrada. El bit más interesante es probablemente el que usa un poco de magia de secuencia para evitar los paréntesis en torno a la adición de los dos argumentos.2x+y-112^+##


2

MATLAB 57 + 6

@(a,b)unique(perms([ones(1,a) zeros(1,b)])*2.^(0:a+b-1)')

correr usando

ans(2,3)

sin golf

function decimalPerms( nZeros, nOnes )
  a = [ones(1,nOnes) zeros(1,nZeros)];  % make 1 by n array of ones and zeros
  a = perms(a);                         % get permutations of the above 
  powOfTwo = 2.^(0:nOnes+nZeros-1)';    % powers of two as vector
  a = a * powOfTwo;                     % matrix multiply to get the possible values
  a = unique(a)                         % select the unique values and print

1
¿Para qué sirven los más 6 bytes?
mbomb007

Estaba a punto de preguntar lo mismo
WallyWest

2

MATL , 9 bytes

y+:<Y@XBu

Pruébalo en línea!

Explicación

El enfoque es similar al de la respuesta de Dennis 'Jelly .

y     % Implicitly take two inputs (say 3, 2). Duplicate the first.
      %   STACK: 3, 2, 3
+     % Add
      %   STACK: 3, 5
:     % Range
      %   STACK: 3, [1 2 3 4 5]
<     % Less  than
      %   STACK: [0 0 0 1 1]
Y@    % All permutations
      %   STACK: [0 0 0 1 1; 0 0 0 1 1; ...; 0 0 1 0 1; ...; 1 1 0 0 0]
XB    % Binary to decimal
      %   STACK: [3 3 ... 5 ... 24]
u     % Unique
      %   STACK: [3 5 ... 24]
      % Implicitly display

1

En realidad, 21 bytes

Un puerto de mi respuesta Ruby . Sugerencias de golf bienvenidas. Pruébalo en línea!

│+)'1*@'0*+╨`εj2@¿`M╔

Cómo funciona

          Implicit input of a and b.
│+)       Duplicate a and b, add, and rotate to bottom of stack. Stack: [b a a+b]
'1*@      "1" times b and swap with a.
'0*+      "0" times a and add to get "0"*a+"1"*b.
╨`...`M   Take all the (a+b)-length permutations of "0"*a+"1"*b
          and map the following function over them.
  εj        Join the permutation into one string
  2@¿       Convert from binary to decimal
╔         Uniquify the resulting list and implicit return.

1

Groovy 74 Bytes, 93 Bytes o 123 Bytes

No sé cuál consideras que responde más completamente la pregunta, pero ...

Solución de 74 bytes

​{a,b->((1..a).collect{0}+(1..b).collect{1}).permutations().unique()}(1,2)

Para una entrada de 1,2 obtienes:

[[1,0,1], [0,1,1], [1,1,0]]

Solución de 93 bytes

{a,b->((1..a).collect{0}+(1..b).collect{1}).permutations().collect{it.join()}.unique()}(1,2)​

Para una entrada de 1,2 obtienes:

[101, 011, 110]

Solución de 123 bytes

{a,b->((1..a).collect{0}+(1..b).collect{1}).permutations().collect{it.join()}.unique().collect{Integer.parseInt(it,2)}}(1,2)

Para una entrada de 1,2 obtienes:

[5, 3, 6]

Pruébalo aquí:

https://groovyconsole.appspot.com/edit/5143619413475328


Estaría contando la solución de 123 bytes, ya que coincide con el tipo de salida mencionado en el resumen. Bien hecho.
WallyWest

1

JavaScript (Firefox 48), 85 76 74 71 70 bytes

Guardado 3 bytes gracias a @Neil.

(m,n,g=x=>x?g(x>>1)-x%2:n)=>[for(i of Array(1<<m+n).keys())if(!g(i))i]

Las comprensiones de matriz son increíbles. Lástima que aún no hayan llegado a la especificación oficial de ECMAScript.

JavaScript (ES6), 109 87 79 78 71 70 bytes

(m,n,g=x=>x?g(x>>1)-x%2:n)=>[...Array(1<<m+n).keys()].filter(x=>!g(x))

Debería funcionar en todos los navegadores compatibles con ES6 ahora. Ahorré 7 bytes en este, también gracias a @Neil.


Uh, @ETHProductions, por alguna razón, estoy volviendo undefinedahora con cada prueba que hago ...?
WallyWest

@WallyWest Asegúrese de asignarlo primero a una variable, por ejemplo f=(m,n)=>..., luego llámelo como f(3,2). Si eso es lo que estás haciendo, ¿qué navegador estás usando?
ETHproductions

Chrome 52 ... No tengo Firefox en esta máquina, así que solo pude probar la versión ES6 que no es Firefox ...
WallyWest

Intentando ejecutarlo en la consola del navegador.
WallyWest

Oh mmm También veo ese problema en Chrome. Pruebe esta evalversión sin (hace exactamente lo mismo, pero 3 bytes más):(m,n)=>{a="";for(i=0;i<1<<m+n;i++)if(i.toString(2).split(1).length==n+1)a+=i+" ";return a}
ETHproductions

1

Groovy 80 Bytes

basado en la respuesta de @carusocomputing

su solución de 123 bytes se puede comprimir en 80 bytes:

Solución de 80 bytes

{a,b->([0]*a+[1]*b).permutations()*.join().collect{Integer.parseInt(it,2)}}(1,2)

Para una entrada de 1,2 obtienes:

[5, 3, 6]

1

C (gcc) , 72 68 bytes

f(a,b){for(a=1<<a+b;a--;)__builtin_popcount(a)^b||printf("%d\n",a);}

Pruébalo en línea!

Desafortunadamente, no hay popcount () en la biblioteca estándar, pero GCC la proporciona como una "función integrada". La salida está ordenada, pero en orden inverso.

¡Gracias a @ceilingcat por reducir 4 bytes!


Aún aceptable ¡Buen trabajo!
WallyWest

0

PHP, 80 o 63 bytes

dependiendo de si debo usar $argvo puedo usar $xy en su $ylugar.

for($i=1<<array_sum($argv);$i--;)echo$argv[2]-substr_count(decbin($i),1)?_:$i._;

imprime todos los números coincidentes en orden descendente delimitados por guiones bajos.
el nombre del archivo no debe comenzar con un dígito.

sin incorporaciones, 88 o 71 bytes

for($i=1<<array_sum($argv);$i--;print$c?_:$i._)for($n=$i,$c=$argv[2];$n;$n>>=1)$c-=$n&1;

agregue un byte cada uno para un solo guión bajo después de cada número.

@WallyWest: Tenías razón. Me ahorra 3 bytes defor($i=-1;++$i<...;)


0

Perl 6 ,  64 62  49 bytes

{(0 x$^a~1 x$^b).comb.permutations.map({:2(.join)}).sort.squish}
{[~](0,1 Zx@_).comb.permutations.map({:2(.join)}).sort.squish}
{(^2**($^x+$^y)).grep:{.base(2).comb('1')==$y}}

Explicación:

# bare block lambda with two placeholder parameters 「$^x」 and 「$^y」
{
  # Range of possible values
  # from 0 up to and excluding 2 to the power of $x+$y
  ( ^ 2 ** ( $^x + $^y ) )

  # find only those which
  .grep:

  # bare block lambda with implicit parameter of 「$_」
  {

    # convert to base 2
    # ( implicit method call on 「$_」 )
    .base(2)

    # get a list of 1s
    .comb('1')

    # is the number of elements the same
    ==

    # as the second argument to the outer block
    $y
  }
}
say {(0..2**($^x+$^y)).grep:{.base(2).comb('1')==$y}}(3,2)
# (3 5 6 9 10 12 17 18 20 24)
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.