Biplex: ein wichtiger nutzloser Operator

33

Eingang

  • Eine Liste von 1 bis 255 positiven ganzen Zahlen (einschließlich), jeweils im Bereich von 1 bis 2 32 - 1 (einschließlich).
  • Ihr Eingabeformat muss nicht mit den Testfällen identisch sein.
  • Eingaben ohne führende Nullen müssen akzeptiert werden.
  • Eingaben mit führenden Nullen müssen nicht akzeptiert werden.
  • Sie können ein beliebiges Trennzeichen zwischen den ganzen Zahlen verwenden.
  • Eine Ganzzahl kann durch eine Zeichenfolge dargestellt werden, die einzelnen Ziffern einer bestimmten Ganzzahl müssen jedoch zusammenhängend sein.
  • Sie können eine beliebige Basis für die Eingabe verwenden (einschließlich binär und unär), vorausgesetzt, die Ausgabe befindet sich ebenfalls in dieser Basis.

Ausgabe

  • Eine einzelne Ganzzahl.
  • Die Ausgabe darf keine führenden Nullen haben.
  • Die Ausgabe muss sich in derselben Basis wie die Eingabe befinden.
  • Die Ausgabe kann nach Belieben berechnet werden, muss jedoch mit dem Ergebnis der folgenden Berechnung übereinstimmen:

Biplex berechnen

  • Die Bits einer Binärdarstellung werden von rechts beginnend mit Null nummeriert, sodass Bit i in der Spalte 2 i darstellt .
  • Die i- te Bitsumme ist die Summe der i- ten Bits der binären Darstellungen jeder der Eingangszahlen.
  • Das Bitmaximum ist der höchste Wert, den die Bitsummen annehmen.
  • Das Bitsummenminimum ist der niedrigste von Null verschiedene Wert, den die Bitsummen annehmen.
  • Die i- te Ziffer der Binärdarstellung des Ausgangs lautet:
    • 1, wenn die i- te Bit - Summe gleich dem Bit-Maximum oder dem Bit-Minimum ist.
    • 0 sonst.

Gearbeitetes Beispiel

In diesem Beispiel wird Binär für die Ein- und Ausgabe verwendet.

Input:    100110
         1101110
         1100101
         _______
Bitsums: 2301321

Output:   101101

Das Bitsummenmaximum ist 3 und das Bitsummenminimum ist 1, daher hat der Ausgang überall 1s, das Bitsummenmaximum 3 oder 1 und überall 0s.


Testfälle

Testfälle sind in der Form:

Input => Output

Die Testfälle in Binär:

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

Dieselben Testfälle in Dezimalform:

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

Bestenliste

Vielen Dank an Martins Leaderboard Snippet


Der Operator wurde nach einer Diskussion im Chat als Biplex (Binary Plane Extrema) bezeichnet .

Trichoplax
quelle
Können wir verlangen, dass die Eingabe wie im Beispiel binär ist?
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. Also ja, machen Sie es :)
Trichoplax
Können wir Notationen wie [[1,0,1], [1,1,0,0], [1,0,0,1]] verwenden?
Akangka
Wahrscheinlich nicht. Nehmen Sie die restriktivste an.
Akangka
@ChristianIrwan Die Eingabe sollte in Form von ganzen Zahlen erfolgen (jeweils bestehend aus zusammenhängenden Ziffern). Eine Ganzzahl kann als Zeichenfolge dargestellt werden, zwischen den Ziffern dürfen jedoch keine Trennzeichen stehen.
Trichoplax

Antworten:

1

Gelee, nicht konkurrierend

14 bytes Diese Antwort ist nicht konkurrierend, da die Herausforderung älter ist als die Erstellung von Jelly.

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

Probieren Sie es online!

Wie es funktioniert

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
quelle
Obwohl es Uneinigkeiten darüber gibt, wie man es genau beurteilt, deutet diese Meta-Frage darauf hin, dass die Community entschieden dafür ist, Antworten nicht mehr als nicht konkurrierend zu markieren, wenn die Herausforderung vor der Erstellung der Sprache liegt. Ich akzeptiere daher diese Antwort.
Trichoplax
11

Pyth, 26 25 Bytes

JsM.T_MjR2Qi_}RhM_BS-J0J2

Probieren Sie es online aus: Demo oder Test Suite

Erläuterung

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
quelle
1
Die _BVerwendung ist brillant
Isaacg
9

J, 31 30 24 23 21 Bytes

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

Dies ist ein stillschweigendes, monadisches Verb, das eine Liste von Dezimalzahlen aufnimmt und deren Dezimal-Biplex zurückgibt.

Vielen Dank an @Zgarb für seine Vorschläge, die 4 Bytes direkt gespeichert und den Weg für 2 weitere geebnet haben!

Vielen Dank an @randomra für das Golfen mit 2 weiteren Bytes!

Testfälle

   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

Wie es funktioniert

                 &.    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
quelle
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.

Eingabe und Ausgabe erfolgen dezimal. Probieren Sie es hier aus.

Erläuterung

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

Alte Version:

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

Probieren Sie es hier aus!

Erläuterung

Der springende Punkt dabei ist, dass die Array- Funktion häufig verwendet wird ( a A), um die Bitsummen zu speichern, von denen das Minimum und das Maximum gefunden werden. Dann werden 1s und 0s entsprechend ausgegeben, wobei führende 0s an zwei Stellen ausgegeben werden .

$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
quelle
Nimmt der Online-Interpreter eine Dezimaleingabe und gibt er eine Binärausgabe aus?
Trichoplax
Ja. Muss ich das ändern?
El'endia Starman,
1
Ahhh, ich habe in den Aufzählungszeichen danach gesucht und es im allerersten Satz verpasst. Ich werde es irgendwann heute beheben.
El'endia Starman
1
Fest! Und mit nur zwei zusätzlichen Bytes! : D
El'endia Starman
1
Du hast meine +1 verdient; Ich bin froh über Minkolang zu lernen.
Lirtosiast
8

Brainfuck , 619 Bytes

Die erste Antwort ist viel zu lange her, also dachte ich, ich würde eine gute machen!

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

Habe ... Habe ich gewonnen?

Dieses Programm erwartet Zeilenumbrüche (ASCII 10) nach jeder Binärzahl und benötigt 32am Ende ein Leerzeichen (ASCII ).

Testläufe:

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

(Neue Zeilen nach jedem Fall mit ++++++++++.am Ende des Programms hinzugefügt)

Erläuterung

Noch in Arbeit, aber langsam. Aus Zeitgründen habe ich die Notizen, die ich beim Schreiben dieses Programms gemacht habe, nur kopiert, was für eine Erklärung vorerst ausreicht:

[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
quelle
Zeilenumbruch getrennt und Leerzeichen beendet ist vollkommen gültig. +1
Trichoplax
7

CJam, 27 Bytes

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

Nimmt Eingaben als Liste im CJam-Stil zur Basis 10. Teste es hier. Alternativ können Sie alle Testfälle ausführen (das Skript verwirft die erwartete Ausgabe und konvertiert das Eingabeformat nach Bedarf).

Erläuterung

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
quelle
Sollte die Ausgabe nicht das Bitmaximum und -minimum sein?
DavidC
1
@DavidCarraher Nein, siehe Beispiele. Die Ausgabe sollte eine Zahl sein, deren Binärdarstellung 1s in den Bits enthält, die den Bitebenen entsprechen, auf denen die Minima und Maxima aufgetreten sind.
Martin Ender
6

JavaScript (ES6), 215 185 176 Byte

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

Verwendung

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

Erläuterung

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
quelle
3
Willkommen bei PPCG! Ich sehe ein paar Möglichkeiten, wie dies verkürzt werden könnte. 1) Wenn Sie eine Pfeilfunktion mit einem Parameter definieren, brauchen Sie keine runden Klammern. f=(a)=>{}= f=a=>{}2) Sie könnten Ihre for...inSchleifen in for...ofSchleifen verwandeln und ein paar Bytes sparen: 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) Bitweises ODER |ändert automatisch Wahr zu 1 und Falsch zu 0, o+=r==q|r==d?1:0;ist also dasselbe wie o+=r==q|r==d;.
ETHproductions
1
Am Ende können Sie machen: return parseInt(o,2)bis:return+('0b'+o)
Downgoat
1
So speichern 2 Bytes, können Sie ersetzen s[l-d-1]=(s[l-d-1]|0)mit s[T=l-d-1]=(s[T]|0). Rasieren mehr 2, ersetzen b=i.toString(2),l=b.length,d=lmit 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.
quelle
3

Simplex v.0.7 , 38 Bytes

Simpl ified Kommentare. Eingabe in Binär, momentan arbeitet kein Interpreter. Hoffentlich sind die Kommentare ausreichend.

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
quelle
3

Oktave, 50 Bytes

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

Beispiel:

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
quelle
Ich würde gerne eine Erklärung für diese sehen ...
Trichoplax
2
@trichoplax ich mit Matlab / Oktave nicht zu brillant bin, aber hoffentlich hilft: @(a)definiert eine anonyme Funktion , die eine Eingabe nimmt Vektor a . ["" erzwingt die Ausgabe in eine Zeichenfolge (glaube ich). (b=sum(a-48))definiert bden Vektor, der die Bitsummen enthält. b==max(b)wird ein Vektor sein, der 1an einer gegebenen Stelle ein hat, wenn die Bitsumme dort ein Maximum hat, und 0ansonsten ein. Ist b(b>0)ein Vektor von jedem Element bgrößer als 0, so b==min(b(b>0))ist ein Vektor ein, der a enthält, 1wenn die Bitsumme das Minimum ist, und 0ansonsten. Dann ist es zusammen ODER und +48für ASCII.
BrainSteel,
@BrainSteel alles macht jetzt Sinn - danke
Trichoplax
Manchmal vergesse ich, wie unterschiedlich Octave und MATLAB sind. Ich denke, ich sollte Octave in Zukunft wirklich zum Golfen einsetzen. Mein kürzester MATLAB-Versuch ist 60 Bytes, weil Sie keine Inline-Zuweisung verwenden können und am Ende function o=b(i)(newline)r=sum(i>48);o=['' (r==max(r)|r==min(r))+48];
Sanchises 10.11.15
3

JavaScript (ES6), 158

Eine Funktion mit einem numerischen Array-Parameter, die eine Zahl zurückgibt. Mit der gleichen Byteanzahl kann ein String-Array-Parameter (der Basis-2-Darstellungen enthält) abgerufen und ein Basis-2-String zurückgegeben werden. Verschieben Sie dazu einfach .toString(2)das Ende nach 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
quelle
3

Haskell, 198 182 178 161 Zeichen

Ich bin noch Anfänger im Golfen. Nur 80 Ruf kommt von der Antwort.

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)

Wie funktioniert es.

Anstelle des Auffüllens kehre ich das Array um und füge es mit dem benutzerdefinierten (&) hinzu. Ich verwende kein foldl1 (zipWith (+)), das kürzer ist, weil zipWith das überflüssige Element löscht. Dann finde ich das Maximum und das Minimum ungleich Null, das auch eine benutzerdefinierte Funktion erforderte. Dann ordne ich das Element dem Maximum und dem Minimum ungleich Null zu, 1, wenn es übereinstimmt, 0, wenn es nicht übereinstimmt. Dann kehren wir es um und wandeln es in eine Binärzahl um.

MACHEN:

  1. Verwenden Data.List
Akangka
quelle
2
In der Definition von wird k, cnur einmal verwendet, daher muss es nicht in die whereKlausel eingefügt werden. Verwenden Sie es direkt: ...||(x==a#b).... Warum die geschweiften Klammern? In l: concat.map showist concatMap showoder noch besser >>=: l=(>>=show).v.... (Anmerkung: Es gibt auch =<<welche, die dasselbe tun, jedoch mit gespiegelten Argumenten:) (show=<<).v.... >>=und hier =<<im Listenkontext arbeiten und verschiedene Dinge in Funktion oder anderen Kontexten tun.
nimi
2
Sie können []in den letzten Fällen von &und ersetzen #durch _: b&_=bund _#l=l.
nimi
2
(x==b)||(x==c)(oder (x==b)||(x==a#b)wenn Sie entfernen c) kann durch elem x[b,c](resp elem x[b,a#b]. :) ersetzt werden .
nimi
2
u=maximumund k a=m(\x->fromEnum$elem x[u a,a#u a])asollte funktionieren.
nimi
1
Tun Sie das nicht _&a=a, es muss bleiben []&a=a, sonst geht die erste Liste verloren, wenn die zweite leer ist. Verwenden Sie _nur im letzten Fall - vielleicht ist das Ihr Fehler.
nimi
3

Python 3, 181 126 122 Bytes

(Ich habe die meisten Schrägstriche bei der Byteanzahl entfernt, weil es ein bisschen lächerlich wurde.) 21 Bytes weniger dank 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)

Etwas weniger Golf gespielt:

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

Die Eingabe wird in Binärform erwartet, wobei die Zahlen nur durch Leerzeichen voneinander getrennt werden. Die Ausgabe erfolgt ebenfalls binär.

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

Vielen Dank für die edc65-Methode für die Min / Max-Berechnung, die meinen Code um 4 Byte verkürzt hat.

Erläuterung

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
quelle
+1 schön. Bit-Arithmetik schlägt String-Konvertierung bei weitem. Und ich sehe 2 Möglichkeiten, um es mehr zu verkürzen.
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
Noch besser! Ich muss mehr über das Golfen für Loops lernen und muss immer noch nicht nach Anweisungen suchen.
Naouak
3

ShapeScript , 186 Byte

'"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?_*!"
"$""~

Eine wichtige, nutzlose Sprache für einen wichtigen, nutzlosen Operator.

I / O ist binär. Das Programm erwartet jede Nummer in einer eigenen Zeile, die mit einem Zeilenvorschub endet.

Probieren Sie es online!

Testfälle

$ 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
quelle
Ich weiß nicht, was dieser Müll ist, den Sie eine Sprache nennen , aber ich liebe es!
Phase
2

APL, 27 Bytes

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

Dies ist eine monadische Funktion, die eine Liste von Dezimalzahlen verwendet und deren Dezimal-Biplex zurückgibt.

Probieren Sie es online in der ngn / apl-Demo aus .

Wie es funktioniert

                     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
quelle
2

Wolfram-Sprache, 113 Bytes

Diese Version nimmt Eingaben von einem Popup-Fenster entgegen, wobei die Zahlen in der Form "{x, y, z, ...}" eingegeben werden (keine Anführungszeichen).

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

Eingang:

Popup-Fenster dynamisch

Ausgabe:

Ausgabe

Nimmt Eingaben in einer dynamischen Manipulation als Zeichenfolge der Form "{x, y, z}" entgegen, wobei x, y und z ganze Zahlen zur Basis 10 sind (mit oder ohne führende Nullen). Die Ausgabe erfolgt ebenfalls in Basis 10.

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

Beispiel

Es gibt andere Möglichkeiten, dies auf eine Art und Weise einzugeben, die die Anzahl der Zeichen einspart, aber ich denke, diese Lösung ist eine elegante Verwendung einer dynamischen GUI, die die Berechnung durchführt

Wenn Sie dies in der Cloud ausführen möchten, können Sie CloudDeploy verwenden:

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

Die Cloud-Bereitstellung erhöht die Anzahl der Charaktere jedoch auf 256 ...

Die Eingabe in FormPage ist auch eine Zeichenfolge der Form "{x, y, z}", wobei x, y und z Ganzzahlen zur Basis 10 sind.

Ich habe dies selbst in der Cloud implementiert und Sie können es unter https://www.wolframcloud.com/objects/97b512df-64f8-4cae-979b-dba6d9622781 ausprobieren

Cloud-Beispiel

Ian Johnson
quelle
Ich habe den Cloud-Link ohne führende Nullen getestet und er gibt immer noch korrekt 3 aus.
Trichoplax
Wenn Sie einen kürzeren Code ohne GUI haben, können Sie diesen in diese Antwort ändern, um Ihre Punktzahl zu verbessern, und die GUI-Version in Ihrer Antwort als alternatives Beispiel belassen, um zu zeigen, was möglich ist. Das Beste aus beiden Welten ...
Trichoplax
@trichoplax Bemerkenswerterweise habe ich mit Input [] die meiner Meinung nach kürzeste Version hinzugefügt. Könnte auch hypothetisch erwarten, dass die Zahlen in einer Variablen gespeichert werden, was auch die Anzahl der Zeichen verringern könnte, aber dann ist es zweideutig, wie Sie die Eingabe eingeben, denke ich
Ian Johnson
Das Speichern der Zahlen in einer Variablen gehört nicht zu den Standardeingabemethoden ... Daher ist dieser zusätzliche Schritt nicht verfügbar, aber was Sie bisher haben, ist großartig :)
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))

Es werden durch Leerzeichen begrenzte Binärzahlen verwendet.

Ungolfed-Version:

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

C #, 255

Ein vollständiges Programm, das als Kommandozeilenargumente (durch Leerzeichen getrennt) in Dezimalzahl eingegeben wird.

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

Besser lesbar:

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

Nimmt ein Array als Eingabe.

MegaTom
quelle
1

CoffeeScript, 194 Bytes

Nimmt Eingaben als durch Kommas getrennte Binärzahlen an, gibt sie als Binärzahlen aus.

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

Versuch es.

MegaTom
quelle
1

GolfScript, 46 Bytes

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

Probieren Sie es online im Web GolfScript aus .

Testfälle

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

C ++, 192 Bytes

Akzeptiert die Eingabe eines vorzeichenlosen 32-Bit-Integer-Arrays und einer Anzahl von Elementen in diesem Array.

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
quelle
1
@trichoplax Ich habe es geändert.
MegaTom