Biplex: un importante operador inútil

33

Entrada

  • Una lista de entre 1 y 255 enteros positivos (inclusive), cada uno en el rango de 1 a 2 32-1 (inclusive).
  • Su formato de entrada no necesita ser idéntico a los casos de prueba.
  • Se requiere la entrada sin ceros a la izquierda para ser aceptada.
  • No es necesario aceptar entradas con ceros a la izquierda.
  • Puede usar cualquier delimitador que desee entre los enteros.
  • Un entero puede estar representado por una cadena, pero los dígitos individuales de un entero específico deben ser contiguos.
  • Puede elegir usar cualquier base para la entrada (incluidos binarios y unarios), siempre que la salida también esté en esa base.

Salida

  • Un solo entero.
  • La salida no debe tener ceros a la izquierda.
  • La salida debe estar en la misma base que la entrada.
  • La salida se puede calcular de la forma que desee, pero debe coincidir con el resultado del siguiente cálculo:

Calculando biplex

  • Los bits de una representación binaria están numerados desde la derecha a partir de cero, por lo que el bit i está en la columna que representa 2 i .
  • El i ésimo Bitsum es la suma de los i th bits de las representaciones binarias de cada uno de los números de entrada.
  • El máximo de suma de bits es el valor más alto tomado por las sumas de bits.
  • El mínimo de suma de bits es el valor más bajo distinto de cero tomado por las sumas de bits.
  • El i ésimo dígito de la representación binaria de la salida es:
    • 1 si la i ésima suma de bits es igual a la suma de bits máxima o la suma de bits mínima.
    • 0 de lo contrario.

Ejemplo trabajado

Este ejemplo usa binario para entrada y salida.

Input:    100110
         1101110
         1100101
         _______
Bitsums: 2301321

Output:   101101

El máximo de suma de bits es 3 y el mínimo de suma de bits es 1, por lo que la salida tiene 1 en todas partes que la suma de bits es 3 o 1, y 0 en todas partes.


Casos de prueba

Los casos de prueba están en la forma:

Input => Output

Los casos de prueba en binario:

[1] => 1
[10] => 10
[1, 10, 101] => 111
[11111111111111111111111111111111] => 11111111111111111111111111111111
[10010010010010010010010010010010, 10101010101010101010101010101010, 11011011011011011011011011011011] => 11100011100011100011100011100011
[10001011100010100110100101001001, 10110000111110010000111110111010, 1101110001101101011010010100101, 1010101010001011101001001010101] => 11 

Los mismos casos de prueba en decimal:

[1] => 1
[2] => 2
[1, 2, 5] => 7
[4294967295] => 4294967295
[2454267026, 2863311530, 3681400539] => 3817748707
[2341103945, 2969112506, 1849078949, 1430639189] => 3

Tabla de clasificación

Gracias al fragmento de la tabla de posiciones de Martin


El operador se llamó biplex, abreviatura de plano binario extremo, luego de una discusión en el chat .

trichoplax
fuente
¿Podemos requerir que la entrada esté en binario, como en el ejemplo?
feersum
1
@feersum You may choose to use any base for input and output (including binary and unary), provided they are both in the same base. Así que sí,
anímate
¿Podemos usar notación como [[1,0,1], [1,1,0,0], [1,0,0,1]]?
Akangka el
Probablemente no. Asume el más restrictivo.
Akangka
@ChristianIrwan La entrada debe estar en forma de enteros (cada uno formado por dígitos contiguos). Un número entero se puede representar como una cadena, pero no debe haber separadores entre los dígitos.
trichoplax

Respuestas:

1

Gelatina, no competidora

14 bytes Esta respuesta no es competitiva ya que el desafío es anterior a la creación de Jelly.

BUSµḟ0Ṣ.ịe€@UḄ

Pruébalo en línea!

Cómo funciona

BUSµḟ0Ṣ.ịe€@UḄ    Main link. Input: A (list)

B                 Convert each item in A to binary.
 U                Reverse each array of binary digits.
  S               Add them across columns.

   µ              Monadic chain. Argument: S (list of column sums)
    ḟ0            Remove all occurrences of 0.
      Ṣ           Sort the remaining sums.
       .ị         Take the elements with indices around 0.5.
                  Indices are 1-bases, so this selects the last and the first one.
             U    Yield S, reversed.
            @     Reverse the arguments.
         e€       Test each item in the left list for membership in the right one.
              Ḅ   Convert from binary to integer.                
Dennis
fuente
Aunque hay desacuerdo sobre cómo juzgarlo exactamente, esta meta pregunta sugiere que la comunidad está firmemente a favor de no marcar más las respuestas como no competitivas cuando el desafío es anterior a la creación del lenguaje. Por lo tanto, estoy aceptando esta respuesta.
trichoplax
11

Pyth, 26 25 bytes

JsM.T_MjR2Qi_}RhM_BS-J0J2

Pruébelo en línea: Demostración o conjunto de pruebas

Explicación

JsM.T_MjR2Q
       jR2Q      convert each input number to binary (lists of 1s and 0s)
     _M          reverse each list
   .T            transpose (with top justify)
 sM              sum up each list (numbers of 1s at each position)
J                store this list in J

i_}RhM_BS-J0J2
         -J0     J without 0s
        S        sorted
      _B         create the list [sorted, reverse(sorted)]
    hM           take the first elments of each (bitsum-min and bitsum-max)
  }R        J    check for each value in J, if it is part of ^
 _               reverse this list of booleans
i            2   convert from binary to base 10 and print
Jakube
fuente
1
El _Buso es brillante
isaacg
9

J, 31 30 24 23 21 bytes

+/(e.>./,<./@#~@)&.#:

Este es un verbo tácito y monádico que toma una lista de enteros decimales y devuelve su biplex decimal.

¡Gracias a @Zgarb por sus sugerencias, que ahorraron 4 bytes directamente y prepararon el camino para 2 más!

¡Gracias a @randomra por jugar 2 bytes más!

Casos de prueba

   biplex =: +/(e.>./,<./@#~@)&.#:

   biplex ,1
1
   biplex ,2
2
   biplex 1 2 5
7
   biplex ,4294967295
4294967295
   biplex 2454267026 2863311530 3681400539
3817748707
   biplex 2341103945 2969112506 1849078949 1430639189
3

Cómo funciona

                 &.    Dual. Apply the verb to the right, the verb to the left,
                       and finally the inverse of the verb to the right.
                   #:  Convert the input list from integer to base 2.
  (            @)      Define an adverb, i.e., an operator that takes a verb as
                       its left argument.
+/                     Call it with "reduce by sum". This calculates the sum of
                       the corresponding binary digits of all integers before
                       executing the remainder of the adverb's body, i.e, this:
             #~          Replicate the sum N a total of N times, i.e., turn
                         0 1 2 3 into 1 2 2 3 3 3. This eliminates zeroes.
         <./@            Calculate the minimum of the result.
     >./                 Calculate the maximum of the sums.
        ,                Append; wrap both extrema into a list.
   e.                    Check if each of the sums is in the list of extrema.
                         This yields 1 if yes and 0 if no.
                       (from &.) Convert from base 2 to integer.
Dennis
fuente
9

Minkolang 0.10 , 109 79 bytes

(n1$(d2%$r2:d)99*I-DmI2:[+1R]$I)rI$d$(s0(x0gd,)Ik3R2g1-X0I3-[2*2gd0c=$r1c=++]N.

La entrada y la salida están en decimal. Pruébalo aquí.

Explicación

(                            $I)    Loop until input is empty
 n                                  Read in number from input
  1$(       d)                      Start a while loop with only the top of stack
     d2%                            Next least-significant bit (modulo by 2)
        $r                          Swap top two values
          2:                        Divide by 2
              99*I-D                Pad with 0s
                                    (when the while loop exits, top of stack is 0)
                    m               Merge (interleave) stack
                     I2:[   ]       For each pair...
                         +1R        Add and rotate stack to the right
                                    <<This does the work of computing bitsums>>

r       Reverse stack
 I      Push length of stack
  $d    Duplicate whole stack
        <<This lets me sort the bitsums without affecting the original order>>

$(                      Start while loop with <top of stack> elements
  s                     Sort
   0(     )             Push a 0 and start another while loop
     x                  Dump top of stack
      0g                Get front of stack and put it on top
        d,              Duplicate and <not> for end-while condition check
           Ik           Push length of stack and break out of while loop
             3R         Rotate [min, max, length] to front
               2g1-     Get length and put it on top, then subtract 1
                   X    Dump that many elements off the top of stack
                        <<Now I have min and max>>

0                        Initialize decimal with 0    
 I3-[               ]    For as many bits as there are...
     2*                  Multiply by 2
       2gd               Get the next most significant bit and put it on top
          0c=            Copy min and check for equality
             $r          Swap top two elements of stack
               1c=       Copy max and check for equality
                  ++     Add 1 if bitsum item is equal to min or max, 0 otherwise
N.                       Output as integer and stop

Versión antigua:

$nI[(d2%i1+0a+i1+0A00ai`4&i00A2:d)x]00a1+[i1+0a]s0(x0gd,)rI2-[x]00a1+[i1+0ad0c=$r1c=+]0gx0gx0(xd,)0I1-[2*+]N.

Pruébalo aquí!

Explicación

El quid de la cuestión es que la función de matriz se usa mucho ( a A) para almacenar los bits, de los cuales se encuentran el mínimo y el máximo, y luego 1s y 0s se emiten adecuadamente, con el volcado de los principales 0s en dos lugares.

$n                                      Read in whole input as integers
  I[(                             x]    Convert each number to binary
     d2%                                Get next least significant bit (modulo by 2)
        i1+0a                           Get current value in array for that position
             +                          Add
              i1+0A                     Put current value in array for that position
                   00ai`                Get first value of array (bitsum length)
                      i`                Greater than loop counter?
                        4&i00A          If not, put loop counter there
                              2:        Divide by 2
                                d)      If 0, exit loop

00a                Get first value of array (maximum length
   1+              Add one
     [i1+0a]       Get bitsum values from array and push on stack
            s      Sort
0(                 Push a 0 (for dump) and start a while loop -- dumps leading 0s
  x                Dump top of stack
   0g              Get bottom of stack
     d,            Duplicate and <not> it
       )           Exit loop when top of stack is non-zero (i.e., the minimum)
        r          Reverse stack (so now it's [min, max, <stuff>])
         I2-[x]    Dump everything else

00a1+[               ]    Get bitsum length and loop that many times
      i1+0a               Get bitsum value at current position
           d              Duplicate
            0c=           Copy front of stack and check for equality
               $r         Swap
                 1c=      Copy next-to-front of stack and check for equality
                    +     Add (so it's 1 if it's equal to min or max, 0 otherwise)

0gx0gx       Dump front two elements of stack (the min and max)
0(xd,)       Dump leading 0s
0            Push 0 for conversion to decimal
 I1-[   ]    For each bit...
     2*+     Multiply by 2 and add
N.           Output as integer and stop
El'endia Starman
fuente
Desde el intérprete en línea, ¿esto toma entrada decimal y da salida binaria?
Trichoplax
Sí. ¿Necesito cambiar eso?
El'endia Starman el
1
Ahhh, lo estaba buscando en las viñetas y lo perdí en la primera oración. Lo arreglaré en algún momento hoy.
El'endia Starman
1
¡Fijo! ¡Y con solo dos bytes adicionales! : D
El'endia Starman
1
Te has ganado mi +1; Me alegra saber sobre Minkolang.
lirtosiast el
8

Brainfuck , 619 bytes

Primera respuesta en demasiado tiempo aquí, ¡así que pensé que haría una buena!

>->->->>>,----------[--<++++++[>------<-]>>>>,----------]-<<<+[-<<<+]->>,<++++[>--------<-]>[<++++[>+++++<-]>++[--<++++++[>------<-]>>>+>]<-[+>-<<+[-<<<+]-<<+[->+[->[-[->>>+<<<]<<<+]+[-->>>++]-<+]<<<+[-[->+<]<<<+]->>+>]<-[+>->>>>+[->>>+]->+[-<[-[->>>+<<<]<<<+]+[-->>>++]->+]-<+<<<+[-[->+<]<<<+]->>]]>,<++++[>--------<-]>]>+[->>>+]>->->>-[+<<<<<<+[-<-<<+]->>[+>>>[>>>]>+[<<->>[->>>+]->>>[-]+<<<<<+[-<<<+]+>->]<]>->>+>-]<[<<<<<+[-<+<<+]->>[-]>+[->>>+]->>-]>-[+<<<<<<+[-<+<<+]->>[->>>[>>>]>+[<<<->>>[->>>+]->>>[-]+<<<<<<+[-<<<+]+>>+>]<]>->>>-]<<<<-<<<<+[->[-]<[->+<]<[->>[-]+<<]<<+]>-[+>>>-]++[->++++++[-<++++++++>]<.>>>+]

¿Gané ... gané?

Este programa espera nuevas líneas (ASCII 10) después de cada número binario y requiere un espacio (ASCII 32) al final.

Pruebas de funcionamiento:

Me$ bf bpx.bf
1
10
101

111

Me$ bf bpx.bf
11111111111111111111111111111111

11111111111111111111111111111111

Me$ bf bpx.bf
10010010010010010010010010010010
10101010101010101010101010101010
11011011011011011011011011011011

11100011100011100011100011100011

Me$ bf bpx.bf
10001011100010100110100101001001
10110000111110010000111110111010
1101110001101101011010010100101
1010101010001011101001001010101

11

(Nuevas líneas agregadas después de cada caso con ++++++++++.agregadas al final del programa)

Explicación

Sigue siendo un trabajo en progreso, pero lento. Por falta de tiempo, acabo de copiar las notas que hice mientras escribía este programa, que será suficiente para una explicación por ahora:

[Biplex Calculator]

[

Bitsum writing philosophy: 

Start with [0 255 255 255 ...].
The 255s will be markers that we can 'search' for to get back to the start.
After that, the next byte should be a 0, fairly permanently. (The first reference 0)
It is useful to have 0-bytes handy for general calculations. 
The next byte is where we will read the first digit of any binary number. (The first read)
The next byte holds the first bitsum.
Afterward, the next byte is 0, the following byte is the place
to read the second binary digit, the following byte is the second bitsum,
and so on.
I'll use the terminology nth reference 0, nth read, and nth bitsum to refer to
each part of the triplet of bytes.

The location three places after the final bitsum will be 255,
and the location three places after the final read will be 255.
We can move entire numbers by lining up these 255s after every binary number.

]


>->->->>>~                  [0 255 255 255 0 0 0 0 0                ]

[From the first bitsum, read input to create an initial set of bitsums                  ]
,----------
[
    --<++++++[>------<-]            [Convert the input '1' or '0' into a bit        ]
    >>>>,---------- 
]~                      
-<<<+[-<<<+]->>                 [Mark 255 after the last bit, then go back to first read]

,<++++[>--------<-]             [Check for space, using the first reference 0       ]
>
[
    <++++[>+++++<-]             [Check for \n                       ]
    >++
    [
        --<++++++[>------<-]        [It wasn't \n, so convert the input into a bit      ]
        >>>+>               [Write 1 to the next reference 0, and go to next read   ]
    ]
    <-
    [
        +>              [It was \n                      ]
        -<              [Mark 255 on this (nth) read and go to (n-1)th bitsum   ]
        <+[-<<<+]           [Search for a 255 off to the left           ]

        [We've either struck our marker, or the last bitsum. We need to check.          ]
        -<<+
        [
            -           [We hit the last bitsum. Move the bitsums right.    ]
            >+
            [
                ->[-[->>>+<<<]<<<+] [Move until we reach the start          ]
                +[-->>>++]      [From the start, move to our last bitsum    ]
                [Repeat this move until the read here is a 255              ]
                -<+
            ]
            [We now need to go to the first reference zero, and put a 1 there       ]
            <<<+[-[->+<]<<<+]->>+>      [Add bits to bitsums and end on first read  ]
        ]
        <-
        [
            +>->>>>+[->>>+]     [Go to the 255 after our reads              ]
            ->+
            [
                -<[-[->>>+<<<]<<<+] [Move until we reach the start          ]
                +[-->>>++]      [From the start, move to the 255 after our reads]
                [Repeat this move until we see the 255 bitsum               ]
                ->+
            ]
            [We now need to go to the first read                        ]
            -<+<<<+[-[->+<]<<<+]->>     [Add bits to bitsums and end on first read  ]
        ]
        >>>>>>>>>>>>>>>>>>>>>>>>>~<<<<<<<<<<<<<<<<<<<<<<<<<
    ]

    [We're at the reference 0 to the left of our next read                      ]
    >,<++++[>--------<-]            [Check for space, using the first reference 0       ]
    >
]

[

Let BN be the nth bitsum. Then our situation at the moment is:

[0 255 255 255 0 0 B1 0 0 B2 ... 0 0 BN 0 0 255] 
                 ^
I'm just happy nothing's exploded yet.

]

[Next goal: Mark the minimums                                       ]

>+[->>>+]>->->>~            [Zero the 255 and put 2 255s after it, then move after it   ]

-[
    +<<<<<<
    +[-<-<<+]               [Subtract one from each bitsum              ]
    ->>
    [
        +>>>[>>>]           [Find the first 0 bitsum                ]
        >+
        [
            <<->>[->>>+]->>>[-]     [Mark the zero as a minimum, and set a flag     ]
            +<<<<<+[-<<<+]+>->
        ]
        <
    ]
    >->>+>-
]~

[Hey, that worked. Weird. Alright, moving on...                             ]
[Reset the bitsums to what they were before we messed them all up                   ]

<[<<<<<+[-<+<<+]->>[-]>+[->>>+]->>-]>~

[After the stuff up there, that's not too bad.                              ]
[Now it's time to mark the maximums, in virtually the opposite way we did the minimums.         ]

-[
    +<<<<<<
    +[-<+<<+]               [Add one to each bitsum                 ]
    ->>
    [
        ->>>[>>>]           [Find the first 0 bitsum                ]
        >+
        [
            <<<->>>[->>>+]->>>[-]   [Mark the zero as a maximum, and set a flag     ]
            +<<<<<<+[-<<<+]+>>+>
        ]
        <
    ]
    >->>>-
]~

[Alright, now OR the maxs and mins, take care of leading zeros, output, and cross fingers       ]
<<<<->>~<<<<<<~+[->[-]<[->+<]<[->>[-]+<<]<<+]>-[+>>>-]++[->++++++[-<++++++++>]<.>>>+]
BrainSteel
fuente
Nueva línea separada y terminada en espacio es perfectamente válida. +1
trichoplax
7

CJam, 27 bytes

q~2fbWf%:.+_0-$(\W>|fe=W%2b

Toma datos como una lista de estilo CJam de base 10. Pruébalo aquí. Alternativamente, ejecute todos los casos de prueba (el script descarta el resultado esperado y convierte el formato de entrada según sea necesario).

Explicación

q~    e# Read and evaluate input.
2fb   e# Convert each number to base 2.
Wf%   e# Reverse each digit list, to align digits in case there are numbers with different 
      e# widths.
:.+   e# Add up the bit planes.
_0-   e# Make a copy and remove zeroes.
$     e# Sort the bit plane sums.
(\W>| e# Get the first and last element. We use set union instead of addition so that the
      e# resulting array will contain only one value if min = max.
fe=   e# For each element in the bit plane sums, count how often it appears in the min/max
      e# array, which is either 1 or 0.
W%    e# Reverse the digits again (to undo the initial reversing).
2b    e# Interpret as base-2 digits.
Martin Ender
fuente
¿No debería ser la salida el máximo y mínimo de bits?
DavidC
1
@DavidCarraher No, vea los ejemplos. La salida debe ser un número cuya representación binaria tenga 1s en esos bits que corresponden a los planos de bits donde ocurrieron los mínimos y máximos.
Martin Ender
6

JavaScript (ES6), 215 185 176 bytes

f=a=>{s=[];for(i of a)for(b=i.toString(2),d=l=b.length;d--;)s[x=l-d-1]=(s[x]|0)+(b[d]|0);q=255;for(r of s)d=r>d?r:d,q=r<q?r||q:q;o="";s.map(r=>o=(r==q|r==d)+o);return+("0b"+o)}

Uso

f([2454267026, 2863311530, 3681400539])
=> 3817748707

Explicación

f=a=>{

  // Create an array of bitsums
  s=[];                   // s = bitsums
  for(i of a)             // iterate through the passed array of numbers
    for(
      b=i.toString(2),    // b = number as binary string
      d=l=b.length;       // l = number of digits in b
      d--;                // iterate through each digit of the binary string
    )
      s[x=l-d-1]=         // add to the digit of the bitsum array
        (s[x]|0)+         // get the current value of the bitsum array (or 0 if null)
        (b[d]|0);         // add the result to the bitsum array

  // Get the maximum and minimum bitsums
  q=255;                  // q = min bitsum
  //d=0;                  // d = max bitsum
  for(r of s)             // iterate through the bitsums
    d=r>d?r:d,            // set d to maximum
    q=r<q?r||q:q;         // set q to minimum

  // Calculate the result
  // (unfortunately JavaScript only supports bitwise operations on signed 32-bit
  // integers so the temporary binary string is necessary)
  o="";                   // o = output
  s.map(r=>               // iterate through the bitsum digits
    o=(r==q|r==d)+o       // add a 1 to the string if the digit is equal to min or max
  );
  return+("0b"+o)         // convert the binary string to a number
}
usuario81655
fuente
3
Bienvenido a PPCG! Veo un par de maneras en que esto podría hacerse más corto. 1) Al definir una función de flecha con un parámetro, no necesita los paréntesis a su alrededor. f=(a)=>{}= f=a=>{}2) Podría convertir sus for...inbucles en for...ofbucles, ahorrando algunos bytes: for(i in a)for(b=a[i]...= for(i of a)for(b=i..., for(i in s)r=s[i],d=...= for(r of s)d=...3) Bitwise O |cambia automáticamente verdadero a 1 y falso a 0, así o+=r==q|r==d?1:0;es lo mismo o+=r==q|r==d;.
ETHproductions
1
Al final puede hacer: return parseInt(o,2)a:return+('0b'+o)
Downgoat
1
Para guardar 2 bytes, puede reemplazar s[l-d-1]=(s[l-d-1]|0)con s[T=l-d-1]=(s[T]|0). Para afeitarse más 2, reemplace b=i.toString(2),l=b.length,d=lcon d=l=(b=i.toString(2)).length.
Ismael Miguel
4

Julia, 141 bytes

A->(s=reduce(.+,map(i->digits(i,2,maximum(map(i->ndigits(i,2),A))),A));parse(Int,reverse(join([1(iextrema(filter(j->j>0,s)))for i=s])),2))

Sin golf:

function biplex(A::AbstractArray)
    # Get the maximum number of binary digits in each element
    # of the input array
    L = maximum(map(i -> ndigits(i, 2), A))

    # Create an array of arrays of binary digits corresponding
    # to the inputs
    B = map(i -> digits(i, 2, L), A)

    # Get the bitsums
    S = reduce(.+, B)

    # Replace the minimum and maximum bitsums with ones and
    # the rest with zeros
    s = [1 * (i in extrema(filter(j -> j > 0, S))) for i in S]

    # Join this into a string and parse it as a base 2 integer
    # Reverse is required because digits() returns the digits
    # in reverse order
    p = parse(Int, reverse(join(s)), 2)

    return p
end
Alex A.
fuente
3

Simplex v.0.7 , 38 bytes

Simpl ified comentarios. Entrada en binario, no hay intérprete trabajando en este momento. Esperemos que los comentarios sean suficientes.

hj&=j&Lun?&RvRpp]{Ri}^XKRJ@jqLhR@LhuTo
h               ]                        ~~ define macro 0
 j&                                      ~~ insert a new byte and write register to it
   =                                     ~~ equal to the previous byte?
    j&                                   ~~ insert a new byte and write register to it
      L                                  ~~ return to equality
       u    v                            ~~ go up/down a strip
        n?&                              ~~ write the register iff byte = 0
           R                             ~~ go right
             Rpp                         ~~ remove two bytes
                 {Ri}                    ~~ take input until input = 0
                     ^X                  ~~ take the sum of the strip
                       K                 ~~ split that sum into digits
                        RJ@              ~~ take the max; write to register
                           jq            ~~ take the min
                             Lh          ~~ call macro 0
                               R@        ~~ set min to register
                                 Lh      ~~ apply macro 0
                                   uTo   ~~ output result 
Conor O'Brien
fuente
3

Octava, 50 bytes

@(a)["" ((b=sum(a-48))==max(b)|b==min(b(b>0)))+48]

Ejemplo:

octave:1> g = @(a)["" ((b=sum(a-48))==max(b)|b==min(b(b>0)))+48] ;
octave:2> g(["10010010010010010010010010010010"; "10101010101010101010101010101010"; "11011011011011011011011011011011"])
ans = 11100011100011100011100011100011
alephalpha
fuente
Me encantaría ver una explicación para este ...
trichoplax
2
@trichoplax No soy demasiado brillante con matlab / octava, pero espero que esto ayude: @(a)define una función anónima que toma un vector de entrada a. ["" fuerza la salida en una cadena (creo). (b=sum(a-48))define bser el vector que contiene los bits. b==max(b)será un vector que tiene un 1en un lugar dado si el bitum allí es un máximo, y un valor distinto 0. b(b>0)es un vector de cada elemento bmayor que 0, por lo que b==min(b(b>0))es un vector que contiene un 1cuando el bit es el mínimo, y de lo 0contrario. Entonces es OR juntos, y +48para ASCII.
BrainSteel
@BrainSteel todo tiene sentido ahora - gracias
trichoplax
A veces me olvido de lo diferentes que son Octave y MATLAB. Supongo que realmente debería comenzar a usar Octave para jugar golf en el futuro, mi intento más corto de MATLAB es de 60 bytes porque no puedes usar la asignación en línea y terminar con function o=b(i)(nueva línea)r=sum(i>48);o=['' (r==max(r)|r==min(r))+48];
Sanchises
3

JavaScript (ES6), 158

Una función con un parámetro de matriz numérica, que devuelve un número. Con el mismo recuento de bytes, podría obtener un parámetro de matriz de cadena (que contiene representaciones de base 2) y devolver una cadena de base 2: simplemente mueva el .toString(2)al final después r.

f=l=>(l.map(v=>[...v.toString(2)].reverse().map((x,i)=>t[i]=~~t[i]-x),t=[]),t.map(v=>(r+=v==Math.min(...t)|v==Math.max(...t.filter(x=>x))&&b,b+=b),r=0,b=1),r)

// More readable

u=l=>(
  t=[],
  l.map(v =>
    [...v.toString(2)]
    .reverse()
    .map((x,i) => t[i] = ~~t[i] - x)
  ),
  r=0,b=1,
  t.map(v => (
    r += v==Math.min(...t) | v==Math.max(...t.filter(x=>x)) && b, b+=b
  )),
  r
)

// Test
console.log=s=>O.innerHTML+=s+'\n'

;[
 [[1], 1]
,[[2], 2]
,[[1, 2, 5], 7]
,[[4294967295], 4294967295]
,[[2454267026, 2863311530, 3681400539], 3817748707]
,[[2341103945, 2969112506, 1849078949, 1430639189], 3]
].forEach(t =>{ 
  r=f(t[0])
  x=t[1]
  console.log('Test '+(r==x?'OK':'Fail (Expected: ' + x +')')
  +'\nInput: '+t[0]+'\nResult: ' +r+'\n')                       
})  
<pre id=O></pre>

edc65
fuente
3

Haskell, 198 182 178 161 caracteres

Todavía soy principiante en el golf. Solo 80 reputación proviene de la respuesta.

m=map
v=reverse
(b:x)&(c:y)=(b+c):x&y
[]&a=a
b&_=b
l=(show=<<).v.(\a->m(fromEnum.(`elem`[maximum a,minimum$(replicate=<<id)=<<a]))a).foldl1(&).m(m(read.(:[])).v)

Como funciona.

En lugar de relleno, invierto la matriz y luego agrego usando el usuario definido (&). No uso foldl1 (zipWith (+)) que es más corto porque zipWith eliminará el elemento superflous. Luego encuentro el mínimo máximo y distinto de cero, que también requería una función definida por el usuario. Luego hago coincidir el elemento con el máximo y el mínimo distinto de cero, 1 si coincide, 0 si no coincide. Luego lo invertimos y lo convertimos en número binario.

QUE HACER:

  1. Utilizando Data.List
Akangka
fuente
2
En la definición de k, csolo se usa una vez, por lo que no es necesario incluirlo en la wherecláusula. Utilizarla directamente: ...||(x==a#b).... ¿Por qué las llaves? En l: concat.map showes concatMap showo aún mejor >>=: l=(>>=show).v.... (Nota: también hay lo =<<que hace lo mismo, pero con argumentos invertidos:) (show=<<).v.... >>=y =<<trabaje en el contexto de la lista aquí y haga cosas diferentes en función u otros contextos.
nimi
2
Puede reemplazar []en los últimos casos de &y #con _: b&_=by _#l=l.
nimi
2
(x==b)||(x==c)(o (x==b)||(x==a#b)cuando lo elimine c) se puede reemplazar por elem x[b,c](resp:) elem x[b,a#b].
nimi
2
u=maximumy k a=m(\x->fromEnum$elem x[u a,a#u a])adebería funcionar
nimi
1
No lo hagas _&a=a, debe quedarse []&a=a, de lo contrario la primera lista se pierde si la segunda está vacía. Úselo _solo en el último caso, tal vez ese sea su error.
nimi
3

Python 3, 181 126 122 bytes

(Eliminé la mayoría de las barras de recuento de bytes porque se estaba volviendo un poco ridículo). 21 bytes de descuento gracias a Eliminé la Sp3000 !

*z,=map(sum,zip(*[map(int,t.zfill(99))for t in input().split()]))
k=0
for x in z:k=k*10+(x in[min(z)or 1,max(z)])
print(k)

Ligeramente menos golfizado:

s=input().split()
k=list(map(lambda t:list(map(int,t))[::-1],s))
z=list(map(sum,zip(*k)))
y=z[:]
while min(y)==0:y.remove(0)
a,b=min(y),max(y)
f=''.join(map(lambda x:str(1*(x in[a,b])),z[::-1]))
print(int(f))

La entrada se espera en binario con solo espacios que separan los números. La salida también está en binario.

El'endia Starman
fuente
3

Javascript, 154 150 bytes

t=i=>(m=0,r=[],i.map(n=>{for(j=31;j+1;r[k=31-j]=(r[k]|0)+((n>>>j)%2),--j);}),r.map(n=>m=(n==Math.min(...r.filter(x=>x))|n==Math.max(...r)?1:0)+m*2),m)

Gracias por el método edc65 para el cálculo mínimo / máximo, acortó mi código en 4 bytes.

Explicación

t=i=>(
    m=0,//m=>output
    r=[],//Bitsum then final number in binary
    i.map(
        n=>
        {
            //Decimal to binary + bitsum
            for(j=31;j+1;r[k=31-j]=(r[k]|0)+((n>>>j)%2),--j);
        }),
    //Output formatting
    r.map(
        n=>
            m=(n==Math.min(...r.filter(x=>x))|n==Math.max(...r)?1:0)+m*2
        ),
    m
)
Naouak
fuente
+1 bien. La aritmética de bits supera la conversión de cadenas con diferencia. Y veo 2 formas de acortarlo más.
edc65
132:f=i=>(m=0,r=[],i.map(n=>{for(k=32;k--;n=n/2|0)r[k]=~~r[k]+n%2}),r.map(n=>m+=m+(n==Math.min(...r.filter(x=>x))|n==Math.max(...r))),m)
edc65
¡Aun mejor! Necesito aprender más sobre golf para bucles, todavía no lo uso para pedir instrucciones.
Naouak
3

ShapeScript , 186 bytes

'"1
"$0?_1-"+"*":2"@~@"0
"~"0
"$"
"~+'1?_*!"2"$"0"~"
"$""~":"1?'@1?"+"$_1>"+"*+@1?"0"+$""~'1?_*!#"0"+@":+"'1?1?"0"+$_2<"+"*+'1?_*!"0"+$"1"~@$"1"~":"$""~"+"$""~'"
"@+"
0"$""~'1?_*!"
"$""~

Un lenguaje importante e inútil para un operador importante e inútil.

I / O está en binario. El programa espera cada número en una línea separada, cada una terminando con un salto de línea.

Pruébalo en línea!

Casos de prueba

$ echo -e '1' | shapescript biplex.shape; echo
1
$ echo -e '10' | shapescript biplex.shape; echo
10
$ echo -e '1\n10\n101' | shapescript biplex.shape; echo
111
$ echo -e '11111111111111111111111111111111' | shapescript biplex.shape; echo11111111111111111111111111111111
$ echo -e '10010010010010010010010010010010\n10101010101010101010101010101010\n11011011011011011011011011011011' | shapescript biplex.shape; echo
11100011100011100011100011100011
$ echo -e '10001011100010100110100101001001\n10110000111110010000111110111010\n1101110001101101011010010100101\n1010101010001011101001001010101' | shapescript biplex.shape; echo
11
Dennis
fuente
No sé qué es esta basura que llamas un idioma , ¡pero me encanta!
fase
2

APL, 27 bytes

{2⊥S∊(⌈/,⌊/)0~⍨S←+/⍵⊤⍨32⍴2}

Esta es una función monádica que toma una lista de enteros decimales y devuelve su biplex decimal.

Pruébelo en línea en la demostración ngn / apl .

Cómo funciona

                     32⍴2  Create a list of 32 2's.
                  ⍵⊤⍨      Base-encode the right argument.
                +/         Add the corresponding binary digits.
              S←           Save the sums in S.
           0~⍨             Remove 0's.
    (⌈/,⌊/)                Apply minimum (⌊/), maximum (⌈/) and concatenate.
  S∊                       Check which binary digits are in the extrema list.
2⊥                         Convert from base 2 to integer.
Dennis
fuente
2

Wolfram Language, 113 bytes

Esta versión toma la entrada de una ventana emergente, con los números ingresados ​​en la forma "{x, y, z, ...}", (sin comillas).

FromDigits[#/.{Max[#]->1,Min[#/.{0->Nothing}]->1,_Integer->0},2]&@Total[PadLeft[IntegerDigits[#,2],33]&/@Input[]]

Entrada:

ventana emergente dinámica

Salida:

salida

Toma entrada en un Manipulado dinámico como una cadena de la forma "{x, y, z}" con x, y y z como enteros de base 10 (con o sin ceros a la izquierda). La salida también está en la base 10.

Manipulate[FromDigits[#/.{Max[#]->1,Min[#/.{0->Nothing}]->1,_Integer->0},2]&@Total[PadLeft[IntegerDigits[#,2],33]&/@ToExpression@i],{i,"{1}"}]

ejemplo

Hay otras formas de ingresar esto de una manera que ahorraría en el recuento de caracteres, pero creo que esta solución es un uso elegante de una GUI dinámica que realiza el cálculo

Si desea ejecutar esto en la nube, podemos usar CloudDeploy:

o=CloudDeploy[FormPage[{"i"->"String"},(FromDigits[#/.{Max[#]->1,Min[#/.{0->Nothing}]->1,_Integer->0},2]&@Total[PadLeft[IntegerDigits[#,2],33]&/@ToExpression@#i])&]];SetOptions[o,Permissions->{All->{"Read","Execute"},"Owner"->{"Read","Write","Execute"}}];o

Sin embargo, la implementación en la nube eleva el número de personajes hasta 256

La entrada al FormPage también es una cadena de la forma "{x, y, z}" con x, y y z como enteros de base 10.

Lo desplegué en la nube yo mismo y puedes probarlo en https://www.wolframcloud.com/objects/97b512df-64f8-4cae-979b-dba6d9622781

ejemplo de nube

Ian Johnson
fuente
He probado el enlace de la nube sin los ceros a la izquierda y todavía
sale
Si tiene un código más corto sin la GUI, puede editarlo en esta respuesta para mejorar su puntaje, y aún dejar la versión de la GUI en su respuesta como un ejemplo alternativo para mostrar lo que es posible. Lo mejor de ambos mundos ...
trichoplax
@trichoplax Notado, agregué lo que creo que es la versión más corta con Input []. Hipotéticamente también podría esperar que los números se almacenen en una variable, lo que también podría disminuir el recuento de caracteres, pero creo que es ambiguo en cuanto a cómo ingresa la entrada en él
Ian Johnson
Almacenar los números en una variable no es uno de los métodos de entrada predeterminados ... Por lo tanto, ese paso adicional no está disponible, pero lo que tiene hasta ahora es genial :)
trichoplax
1

Pitón 3, 197

import itertools
o='0'
d=[sum(map(int,n))for n in itertools.zip_longest(*map(reversed,input().split(' ')),fillvalue=o)]
m=max(d),min(d)or 1
print(''.join((o,'1')[g in m]for g in d[::-1]).lstrip(o))

Toma en el espacio delimitado números binarios.

Versión sin golf:

import itertools
nums = map(reversed, input().split(' '))
digits = []
for num in itertools.zip_longest(*nums, fillvalue='0'):
    current_digit = sum(map(int,num))
    digits.append(current_digit)
bit_max = max(digits)
bit_min = min(digits) or min(digits) + 1
print(''.join(('0','1')[digit in(bit_max,bit_min)]for digit in digits[::-1]).lstrip('0'))
Morgan Thrapp
fuente
1

C #, 255

Un programa completo, ingresado como argumentos de línea de comando - separados por espacios - en decimal.

using System.Linq;class P{static void Main(string[]l){var n=new uint[32];uint i,r=0,b;foreach(var v in l)for(i=0,b=uint.Parse(v);b!=0;b/=2)n[i++]+=b&1;b=1;foreach(var v in n){r+=(v==n.Max()|v== n.Min(x=>x>0?x:n.Max()))?b:0;b+=b;}System.Console.Write(r);}}

Más legible:

using System.Linq;

class P
{
    static void Main(string[] l)
    {
        var n = new uint[32];
        uint i, r = 0, b;

        foreach (var v in l)
            for (i = 0, b = uint.Parse(v); b != 0; b /= 2) n[i++] += b & 1;
        b = 1;
        foreach (var v in n)
        {
            r += (v == n.Max() | v == n.Min(x => x > 0 ? x : n.Max())) ? b : 0;
            b += b;
        }
        System.Console.Write(r);
    }
}
edc65
fuente
1

Rubí, 127 bytes

def f l;a=[];32.times{|i|a[i]=0;l.each{|n|;a[i]+=n[i]}};a.map{|b|a.reject{|c|c==0}.minmax.index(b)?1:0}.reverse.join.to_i 2;end

Toma una matriz como entrada.

MegaTom
fuente
1

CoffeeScript, 194 bytes

Toma la entrada como números binarios separados por coma, salidas en binario.

a=(s.split('').reverse()for s in prompt().split(','))
for i in b=[0..31]
 b[i]=0
 b[i]+=+c[31-i]||0for c in a
m=1/M=0
for d in b
 M=d if d>M;m=d if m>d&&d
alert +(+(d in[m,M])for d in b).join ''

Intentalo.

MegaTom
fuente
1

GolfScript, 46 bytes

~{2base-1%}%zip{{+}*}%-1%.$0-)\1<|`{&,}+%2base

Pruébelo en línea en Web GolfScript .

Casos de prueba

$ golfscript biplex.gs <<< '[1]'
1
$ golfscript biplex.gs <<< '[2]'
2
$ golfscript biplex.gs <<< '[1 2 5]'
7
$ golfscript biplex.gs <<< '[4294967295]'
4294967295
$ golfscript biplex.gs <<< '[2454267026 2863311530 3681400539]'
3817748707
$ golfscript biplex.gs <<< '[2341103945 2969112506 1849078949 1430639189]'
3
Dennis
fuente
1

C ++, 192 bytes

Acepta la entrada de una matriz de enteros sin signo de 32 bits y un recuento de elementos en esa matriz.

typedef unsigned long U;U b(U*a,int c){U x[32],t,i,j,M=0,m=c,r=0;for(i=0;i<32;x[i++]=t,m=t&&m>t?t:m,M=M<t?t:M)for(t=j=0;j<c;)t+=a[j++]>>i&1;for(i=0;i<32;++i)r|=(x[i]==m||x[i]==M)<<i;return r;}

Sin golf:

unsigned long b(unsigned long*a, int c){
    unsigned long x[32],t,i,j,M=0,m=c,r=0;
    for(i=0;i<32;x[i++]=t){
        m = (t && m > t)?t:m;
        M = M < t ? t:M;
        for(t=j=0;j<c;){
            t+=a[j++]>>i&1;
        }
    }
    for(i=0;i<32;++i)
        r|=(x[i]==m||x[i]==M)<<i;
    return r;
}
MegaTom
fuente
1
@trichoplax lo cambié.
MegaTom