Biplex: um importante operador inútil

33

Entrada

  • Uma lista de 1 a 255 números inteiros positivos (inclusive), cada um no intervalo de 1 a 2 32 - 1 (inclusive).
  • Seu formato de entrada não precisa ser idêntico aos casos de teste.
  • A entrada sem zeros à esquerda é necessária para ser aceita.
  • A entrada com zeros à esquerda não precisa ser aceita.
  • Você pode usar o delimitador que desejar entre os números inteiros.
  • Um número inteiro pode ser representado por uma sequência, mas os dígitos individuais de um número inteiro específico devem ser contíguos.
  • Você pode optar por usar qualquer base para a entrada (incluindo binária e unária), desde que a saída também esteja nessa base.

Saída

  • Um único inteiro.
  • A saída não deve ter zeros à esquerda.
  • A saída deve estar na mesma base que a entrada.
  • A saída pode ser calculada da maneira que você desejar, mas deve corresponder ao resultado do seguinte cálculo:

Calculando biplex

  • Os bits de uma representação binária são numerados da direita, começando do zero, então o bit i está na coluna que representa 2 i .
  • O i th Bitsum é a soma dos i th bits das representações binárias de cada um dos números de entrada.
  • O máximo de bits é o valor mais alto obtido pelos bits.
  • O mínimo de bits é o menor valor diferente de zero obtido pelos bits.
  • O i- ésimo dígito da representação binária da saída é:
    • 1 se o i- ésimo bit for igual ao máximo de bits ou mínimo de bits.
    • 0 caso contrário.

Exemplo trabalhado

Este exemplo usa binário para entrada e saída.

Input:    100110
         1101110
         1100101
         _______
Bitsums: 2301321

Output:   101101

O máximo de bits é 3 e o mínimo de bits é 1; portanto, a saída tem 1s em todos os lugares em que o bitsum é 3 ou 1 e 0s em qualquer outro lugar.


Casos de teste

Os casos de teste estão no formato:

Input => Output

Os casos de teste em binário:

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

Os mesmos casos de teste em decimal:

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

Entre os melhores

Agradecimentos ao snippet da tabela de classificação de Martin


O operador foi nomeado biplex, abreviação de extremo do plano binário, após discussão no chat .

Trichoplax
fonte
Podemos exigir que a entrada seja binária, como no exemplo?
precisa saber é
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. Então, sim, ir para ele :)
Trichoplax
Podemos usar notação como [[1,0,1], [1,1,0,0], [1,0,0,1]]?
Akangka 4/11
Provavelmente não. Suponha o mais restritivo.
Akangka 4/11
@ChristianIrwan A entrada deve estar na forma de números inteiros (cada um composto por dígitos contíguos). Um número inteiro pode ser representado como uma sequência, mas não deve haver separadores entre os dígitos.
Trichoplax

Respostas:

1

Gelatina, não concorrente

14 bytes Esta resposta não é competitiva, pois o desafio antecede a criação do Jelly.

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

Experimente online!

Como 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
fonte
Embora haja desacordo sobre exatamente como julgá-lo, essa meta questão sugere que a comunidade é fortemente a favor de deixar de marcar as respostas como não concorrentes quando o desafio antecede a criação do idioma. Estou, portanto, aceitando esta resposta.
Trichoplax
11

Pitão, 26 25 bytes

JsM.T_MjR2Qi_}RhM_BS-J0J2

Experimente on-line: Demonstration or Test Suite

Explicação

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
fonte
1
O _Buso é brilhante
isaacg
9

J, 31 30 24 23 21 bytes

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

É um verbo tácito e monádico que pega uma lista de números inteiros decimais e retorna seu biplex decimal.

Agradecemos a @Zgarb por suas sugestões, que salvaram 4 bytes diretamente e abriram o caminho para mais 2!

Graças a @randomra por jogar fora mais 2 bytes!

Casos de teste

   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

Como 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
fonte
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.

Entrada e saída estão em decimal. Experimente aqui.

Explicação

(                            $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

Versão antiga:

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

Experimente aqui!

Explicação

O ponto crucial disso é que o recurso de matriz é muito usado ( a A) para armazenar as somas de bits, das quais o mínimo e o máximo são encontrados, 1e se os 0s são emitidos adequadamente, com o despejo dos 0s principais em dois 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
fonte
Do intérprete online, isso recebe entrada decimal e gera saída binária?
precisa saber é o seguinte
Sim. Preciso mudar isso?
El'endia Starman 04/11/2015
1
Ahhh, eu estava procurando nos pontos de bala e perdi na primeira frase. Eu vou consertar isso hoje.
El'endia Starman 5/11
1
Fixo! E com apenas dois bytes extras! : D
El'endia Starman 5/11
1
Você ganhou meu +1; Fico feliz em aprender sobre Minkolang.
lirtosiast
8

Brainfuck , 619 bytes

A primeira resposta é longa demais aqui, então pensei em fazer uma boa!

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

Eu ganhei?

Este programa espera novas linhas (ASCII 10) após cada número binário e requer um espaço (ASCII 32) no final.

Execuções de teste:

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

(Novas linhas adicionadas após cada caso e ++++++++++.adicionadas ao final do programa)

Explicação

Ainda um trabalho em andamento, mas lento. Por falta de tempo, acabei de copiar as anotações que fiz enquanto escrevia este programa, o que será suficiente para uma explicação por enquanto:

[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
fonte
Nova linha separada e espaço terminado é perfeitamente válido. +1
trichoplax
7

CJam, 27 bytes

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

Recebe a entrada como uma lista no estilo CJam de base 10. Teste aqui. Como alternativa, execute todos os casos de teste (o script descarta a saída esperada e converte o formato de entrada conforme necessário).

Explicação

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
fonte
A saída não deve ser o bitum máximo e mínimo?
DavidC
1
@DavidCarraher Não, veja os exemplos. A saída deve ser um número cuja representação binária tenha 1s nos bits que correspondem aos planos de bits em que os mínimos e máximos ocorreram.
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

Explicação

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
}
user81655
fonte
3
Bem-vindo ao PPCG! Vejo algumas maneiras pelas quais isso poderia ser reduzido. 1) Ao definir uma função de seta com um parâmetro, você não precisa dos parênteses em torno dele. f=(a)=>{}= f=a=>{}2) Você pode transformar seus for...inloops em for...ofloops, economizando alguns 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 OR |muda automaticamente true para 1 e false para 0, assim o+=r==q|r==d?1:0;é o mesmo que o+=r==q|r==d;.
ETHproductions
1
No final, você pode fazer: return parseInt(o,2)para:return+('0b'+o)
Downgoat 5/11/2015
1
Para economizar 2 bytes, você pode substituir s[l-d-1]=(s[l-d-1]|0)por s[T=l-d-1]=(s[T]|0). Para barbear mais 2, substitua b=i.toString(2),l=b.length,d=lpor 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))

Ungolfed:

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.
fonte
3

Simplex v.0.7 , 38 bytes

Simpl ified comentários. Entrada em binário, nenhum intérprete trabalhando no momento. Espero que os comentários sejam 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
fonte
3

Oitava, 50 bytes

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

Exemplo:

octave:1> g = @(a)["" ((b=sum(a-48))==max(b)|b==min(b(b>0)))+48] ;
octave:2> g(["10010010010010010010010010010010"; "10101010101010101010101010101010"; "11011011011011011011011011011011"])
ans = 11100011100011100011100011100011
alefalpha
fonte
Eu adoraria ver uma explicação para este ...
Trichoplax
2
@trichoplax Eu não sou muito brilhante com matlab / oitava, mas espero que isso ajude: @(a)define uma função anônima que aceita um vetor de entrada a. ["" força a saída em uma string (acredito). (b=sum(a-48))define bcomo o vetor que contém os bitss. b==max(b)será um vetor tendo um 1em um determinado local se o bitsum houver um máximo e 0outro. b(b>0)é um vetor de cada elemento bmaior que 0, portanto, b==min(b(b>0))é um vetor que contém a 1quando o bit é o mínimo e, 0caso contrário. Então é OR'd juntos, e +48para ASCII.
BrainSteel
@BrainSteel tudo faz sentido agora - obrigado
trichoplax 4/15
Às vezes eu esqueço o quão diferentes o Octave e o MATLAB são. Acho que eu deveria realmente começar a usar Octave para jogar golfe no futuro, a minha tentativa MATLAB mais curto é de 60 bytes, porque você não pode usar a atribuição em linha e acabar com function o=b(i)(nova linha)r=sum(i>48);o=['' (r==max(r)|r==min(r))+48];
Sanchises
3

JavaScript (ES6), 158

Uma função com um parâmetro de matriz numérica, retornando um número. Com a mesma contagem de bytes, ele pode obter um parâmetro de matriz de string (contendo representações de base 2) e retornar uma string de base 2 - basta mover o .toString(2)no final depois 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
fonte
3

Haskell, 198 182 178 178 161 caracteres

Eu ainda sou iniciante no golfe. Apenas 80 reputação vem da resposta.

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.

Em vez de preenchimento, inverto a matriz e adiciono usando o definido pelo usuário (&). Eu não uso foldl1 (zipWith (+)) que é mais curto porque zipWith excluirá o item supérfluo. Então eu acho o mínimo máximo e o zero diferente, que também exigiam função definida pelo usuário. Em seguida, associo o item ao mínimo e ao mínimo, zero se corresponder, 0 se não corresponder. Então nós invertemos e o transformamos em número binário.

FAÇAM:

  1. Usando Data.List
Akangka
fonte
2
Na definição de k, cé usado apenas uma vez, portanto, não é necessário colocá-lo na wherecláusula Usá-lo diretamente: ...||(x==a#b).... Por que os suspensórios? Em l: concat.map showé concatMap showou até melhor>>= : l=(>>=show).v.... (Nota: há também o =<<que faz o mesmo, mas com argumentos invertidos:) (show=<<).v.... >>=e =<<trabalhe no contexto de lista aqui e faça coisas diferentes em função ou em outros contextos.
N
2
Você pode substituir []nos últimos casos de &e #por _: b&_=be _#l=l.
N
2
(x==b)||(x==c)(ou (x==b)||(x==a#b)quando você remover c) pode ser substituído por elem x[b,c](resp:) elem x[b,a#b].
N
2
u=maximume k a=m(\x->fromEnum$elem x[u a,a#u a])adeve funcionar.
N
1
Não faça _&a=a, ele deve permanecer []&a=a; caso contrário, a primeira lista será perdida se a segunda estiver vazia. Use _apenas no último caso - talvez esse seja o seu erro.
N
3

Python 3, 181 126 122 bytes

(Tirei a maioria das barras de contagem de bytes porque estava ficando um pouco ridícula.) 21 bytes de desconto graças ao 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)

Um pouco menos golfe:

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

A entrada é esperada em binário com apenas espaços separando os números. A saída também é binária.

El'endia Starman
fonte
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)

Obrigado pelo método edc65 para o cálculo mínimo / máximo, ele reduziu meu código em 4 bytes.

Explicação

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
fonte
+1 legal. A aritmética de bits supera a conversão de cadeia de longe. E vejo duas maneiras de reduzi-lo mais.
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
Melhor ainda! Preciso aprender mais sobre jogar golfe em loops, ainda não o uso para procurar instruções.
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?_*!"
"$""~

Uma linguagem importante e inútil para um operador importante e inútil.

AE / S está em binário. O programa espera cada número em uma linha separada, cada um terminando com um avanço de linha.

Experimente online!

Casos de teste

$ 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
fonte
Eu não sei o que esse lixo é que você chama de idioma , mas eu adoro!
fase
2

APL, 27 bytes

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

Esta é uma função monádica que pega uma lista de números inteiros decimais e retorna seu biplex decimal.

Experimente online na demonstração ngn / apl .

Como 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
fonte
2

Wolfram Language, 113 bytes

Esta versão recebe entrada de uma janela pop-up, com os números inseridos no formato "{x, y, z, ...}", (sem aspas).

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

Entrada:

janela pop-up dinâmica

Saída:

saída

Recebe entrada em um Manipulado dinâmico como uma sequência do formato "{x, y, z}", com x, ye z sendo base 10 inteiros (com ou sem zeros à esquerda). A saída também está na base 10.

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

exemplo

Existem outras maneiras de inserir isso de uma maneira que economizasse a contagem de caracteres, mas acho que essa solução é um uso elegante de uma GUI dinâmica que executa a computação

Se você deseja executar isso na nuvem, podemos usar o 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

A implantação na nuvem traz a contagem de caracteres até 256, no entanto ...

A entrada para o FormPage também é uma sequência do formato "{x, y, z}", com x, ye z sendo base 10 inteiros.

Eu mesmo implantei isso na nuvem e você pode experimentá-lo em https://www.wolframcloud.com/objects/97b512df-64f8-4cae-979b-dba6d9622781

exemplo de nuvem

Ian Johnson
fonte
Testei o link da nuvem sem os zeros à esquerda e ele ainda gera corretamente 3.
Trichoplax
Se você tiver um código mais curto sem a GUI, poderá editá-lo nesta resposta para melhorar sua pontuação e ainda deixar a versão da GUI na sua resposta como um exemplo alternativo para mostrar o que é possível. Melhor dos dois mundos ...
Trichoplax
@ Trichoplax Notado, eu adicionei o que eu acho que é a versão mais curta com o Input []. Poderia também esperar, hipoteticamente, que os números fossem armazenados em uma variável, o que também poderia diminuir a contagem de caracteres, mas é ambíguo o modo como você insere a entrada.
Ian Johnson
Armazenar os números em uma variável não é um dos métodos de entrada padrão ... Assim que passo adicional não está disponível, mas o que temos até agora é grande :)
Trichoplax
1

Python 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))

Leva em números binários delimitados por espaço.

Versão não destruída:

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
fonte
1

C #, 255

Um programa completo, inserido como argumentos de linha de comando - separados por espaço - em 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);}}

Mais legível:

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
fonte
1

Ruby, 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 uma matriz como entrada.

MegaTom
fonte
1

CoffeeScript, 194 bytes

Recebe entrada como números binários separados por coma, sai em binário.

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

Tente.

MegaTom
fonte
1

GolfScript, 46 bytes

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

Experimente online no Web GolfScript .

Casos de teste

$ 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
fonte
1

C ++, 192 bytes

Aceita a entrada de uma matriz inteira não assinada de 32 bits e uma contagem de itens nessa 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;}

Ungolfed:

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
fonte
1
@trichoplax eu mudei.
MegaTom 13/11/2015