Natürlich weiß das SE-Netzwerk sehr genau, wie man auf der Toilette respektvoll ist, aber für diejenigen unter Ihnen, die eine Zusammenfassung benötigen, bedeutet Respekt, die Toilette zu spülen usw. Am wichtigsten ist jedoch, dass der Stand so weit weg benutzt wird von anderen wie möglich.

Die Herausforderung

Angesichts eines Entwurfs für eine Reihe von Ständen mit Hinweisen darauf, welche als Zeichenfolge verwendet werden, müssen Sie von einer Funktion oder einem Programm zurückkehren oder drucken, bei der der respektvollste Ort für Ihre Geschäftstätigkeit ist.

Die Eingabe

 0 1 2 3 4 5    <- The stall number which is not actually visible in the input. 
| | |-| |-|-|   <- the stalls

Die Stände sind von links nach rechts aufsteigend nummeriert. Es wird immer mindestens einen freien Stand geben. Ein Eingang kann bis zu 50 Boxen enthalten. Sie können die Eingabe auch als Array oder als Zeichenfolge von 0s und 1s oder als Boolesche Werte verwenden, wenn Sie dies vorziehen.

Stände in Gebrauch haben -(zwischen den Rohren).

Die Ausgabe

Der respektvollste Stand ist derjenige, der im Durchschnitt am weitesten von den genutzten entfernt ist. Der Abstand zwischen zwei Boxen ist der absolute Wert der Differenz der darüber liegenden Zahlen.

Um es klar auszudrücken: Sie ermitteln die durchschnittliche Entfernung zu allen Ständen - nicht nur zu den benachbarten.

Sie müssen die niedrigste Nummer des respektvollsten Standes ausgeben, um dorthin zu gelangen , der leer ist .

Beispiele

Input:
|-| |-| OR 101
Output:
1

Input:
| | |-| |-|-| OR 001011
Output:
0

Input:
|-| |-| | | | |-|-| OR 101000011
Output:
1

Input: 
|-| | | | | |-|-| | | | | OR 100000110000
Output:
11

Input:
|-|-|-|-| | | | | | |-| OR 11110000001
Output:
9

Input:
|-| | OR 10
Output:
1

Input:
|-| | |-| OR 1001
Output:
1

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes!

Sie können in Ihrer Antwort eine auf 0 oder 1 basierende Indexierung verwenden - je nachdem, was Sie bevorzugen. Wenn Sie 1-basierte Indizierung verwenden, müssen Sie dies in Ihrer Antwort explizit angeben.

Gelee , 10 9 Bytes

JạþTS׬MḢ

Verwendet 1-basierte Indizierung. Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

JạþTS׬MḢ  Main link. Argument: A (array of Booleans)

J          Yield all indices of A.
   T       Yield all truthy indices of A.
 ạþ        Compute the table of absolute differences.
    S      Compute the sums of all columns.
           For each index, this yields the sum of all distances to occupied stalls.
     ׬    Multiply each sum by the logical NOT of the corresponding Boolean in A.
           This zeroes sums that correspond to occupied stalls.
       M   Maximal; yield an array of all indices of maximal sums.
        Ḣ  Head; extract the first index.

Schnell, 158, 157, 128, 100 Bytes

Übernimmt die Eingabe von der Array<Bool>Variableni und gibt die Antwort vom letzten Ausdruck zurück.

let e=i.characters.map{$0>"0"}.enumerate()
e.flatMap{$1 ?nil:$0}.map{a in(a,e.flatMap{$1 ?$0:nil}.map{abs(a-$0)}.reduce(0){$0+$1})}.maxElement{$0.1 < $1.1}!.0

Bearbeiten 1:

Ein Byte wurde gespeichert, indem es über einen Zeichenfolgenvergleich in Bools konvertiert wurde

let e=i.characters.map{$0=="1"}.enumerate()
e.flatMap{$1 ?nil:$0}.map{a in(a,e.flatMap{$1 ?$0:nil}.map{abs(a-$0)}.reduce(0){$0+$1})}.maxElement{$0.1 < $1.1}!.0

Bearbeiten 2:

Überarbeitete meinen Algorithmus:

let e=i.characters.map{$0=="1"}.enumerate()
e.map{x in(x.0,x.1 ?0:e.reduce(0){$1.1 ?$0+abs(x.0-$1.0):$0})}.max{$0.1<$1.1}!.0

Edit 3:

Nutzte die neue Regel, mit der Eingaben direkt von einem booleschen Array übernommen werden können.

let e=i.enumerated()
e.map{x in(x.0,x.1 ?0:e.reduce(0){$1.1 ?$0+abs(x.0-$1.0):$0})}.max{$0.1<$1.1}!.0

Ungolfed:

// for the sake of easier copy/pasting of input, take it as string
let s = "100000110000"

// convert input to true for taken, false for free
// this is the input the golfed version actually uses
let input = s.characters.map{$0>"0"}

// Returns an array of tuples storing the array values (vacancy of the stall) and their index (their location)
let valueIndexPairs = bools.enumerated()

// Returns an array of pairs of locations and their avg distance to others
let locationDistancePairs = valueIndexPairs.map{(valueIndexPair: (Int, Bool)) -> (Int, Int) in

    let averageDistance = valueIndexPairs.reduce(0) {partialSum, otherStall in

        let otherStallIsTaken = otherStall.1

        if otherStallIsTaken {
            //don't let other stalls effect average if they're taken
            return partialSum
        }
        else {
            let thisStallLocation = valueIndexPair.0
            let otherStallLocation = otherStall.0
            let distanceToOtherStall = abs(thisStallLocation - otherStallLocation)
            return partialSum + distanceToOtherStall 
        }       
    }

    //if this stall is taken, treat its average distance to others as 0
    let thisStallsLocation = valueIndexPair.0
    let isThisStallTaken = valueIndexPair.1
    return (thisStallsLocation, isThisStallTaken ? 0 : averageDistance)
}

//find location where average distance is maxiumum
let bestLocationIndexPair = locationDistancePairs.max{$0.1 < $1.1}!

let bestLocation = bestLocationIndexPair.0

print(bestLocation)

Jelly , 13 Bytes

1-indiziert.

³Tạ⁸S
JUÇÞḟTṪ

Probieren Sie es online!

Algorithmus

Naive Umsetzung der Frage.

Java "nur" 270 200 196 187 196 138 148 146 Bytes!

sparte 4 13 unzählige Bytes dank Leaky Nun! 1 Byte dank Micheal Golfed

int m(boolean[]b){int r=0,l=b.length,i,j,k=0,z=r;for(i=0;i<l;i++){if(b[i])for(j=0,k=0;j<l;j++)if(!b[j])k+=i>j?i-j:j-i;if(k>z){r=i;z=k;}}return r;}

Ungolfed

int m(int[] s) {
        int l=s.length,i,j=0,k=0;
    boolean[] b = new boolean[l];
    int[] a = new int[l];
    //see what stalls are open
    for (i = 0; i < s.length; i++) {
        if (s[i] == 0){
            b[i] = true;
        }
    }
    //assign the sum of distance to the a[]
    for (i = 0; i < l; i++) {
        if (b[i]) {
            for (j = 0; j < l; j++) {
                if (!b[j]) {
                    a[i]+= Math.abs(i - j);
                }
            }
        }
    }
    //find the stall the greatest distance away breaking ties based on the furthest left
    for (i = 0; i < l; i++) {
        if (b[i] && (a[i] > k || k == 0)) {
            k = a[i];
            j=i;
        }
    }
    //return the index
    return j;
}

Eingabe als boolesches Array, wobei true eine Unterbrechung impliziert.

Ruby, 79 78 76 + nFlag = 77 Bytes

Die Ausgabe ist eine 0-basierte Indizierung. Der Eingang ist die STDIN-Zeile mit den Nullen und Einsen.

p (r=0...~/$/).max_by{|i|k=0;$_[i]>?0?0:r.map{|j|k+=$_[j]<?1?0:(j-i).abs};k}

MATL , 14 Bytes

~ftGf!-|Xs&X>)

Probieren Sie es online!

Die Ausgabe ist 1-basiert.

Erläuterung

~f     % Implicitly take input. Compute row vector with indices of zeros
t      % Duplicate that
Gf!    % Push input again. Compute column vector of indices of ones
-|     % Absolute differences with broadcast. Gives 2D array with all combinations
Xs     % Sum of each column
&X>    % Arg max. Gives the index of the first maximizer if there are several
)      % Index into row vector of indices of zeros. Implictly display

Perl 84 + 3 ( -alpFlags) = 87 Bytes

for$i(0..$#F){$t=0;map{$t+=abs($i-$_)*$F[$_]}0..$#F;($m,$_)=($t,$i)if$m<$t&&!$F[$i]}

Benötigt -alpFlags zum Laufen. Nimmt eine durch Leerzeichen getrennte Zeichenfolge von 1 und 0 als Eingabe. Zum Beispiel :

perl -alpe '$m=0;for$i(0..$#F){$t=0;map{$t+=abs($i-$_)*$F[$_]}0..$#F;($m,$_)=($t,$i)if$m<$t&&!$F[$i]}' <<< "1 0 1
0 0 1 0 1 1
1 0 1 0 0 0 0 1 1
1 0 0 0 0 0 1 1 0 0 0 0
1 1 1 1 0 0 0 0 0 0 1
1 0"

Beachten Sie, dass ich $m=0am Anfang hinzugefügt habe , aber das ist nur, um es an mehreren Einträgen zu testen.

Matlab, 87 Bytes

n=input('');k=numel(n);[a b]=ndgrid(1:k);[x y]=max(sum(abs(a-b).*repmat(n,k,1)').*~n);y

Nimmt eine Reihe von Einsen und Nullen; verwendet 1-basierte Indizierung.
Wie bei einigen anderen Antworten wird die durchschnittliche Gesamtentfernung nicht maximiert.
Möglicherweise gibt es noch mehr Möglichkeiten zum Golfen ...

JavaScript (ES6), 87 86 82 75 Byte

a=>a.map((u,i)=>u||(a.map((v,j)=>u+=v*(i>j?i-j:j-i)),u>x&&(x=d,r=i)),x=0)|r

Nimmt ein boolesches Array (true / false oder 1/0). Es macht keinen Sinn, die durchschnittliche Entfernung zu berechnen, da alle denselben gemeinsamen Faktor verwenden. Berechnen Sie also einfach die Gesamtentfernung für jeden Stand und suchen Sie den ersten Index des höchsten. Bearbeiten: 1 Byte mit *anstelle von gespeichert &&. 5 Bytes gespart, indem die höchste Entfernung manuell anhand eines Kommentars von @Dendrobium ermittelt wurde. 7 Bytes durch Wiederverwendung uals Pseudoreduzierungsakkumulator auf der Grundlage eines Kommentars von @ edc65 eingespart.

J, 27 Bytes

(#{:@-.~]/:[:+/]|@-/~#)i.@#

Online-Dolmetscher .

Rubin, 87 76 Bytes

Warf diesen ersten Entwurf schnell zusammen, aber in der Zwischenzeit Value Ink bereits eine 80-Byte-Ruby-Antwort veröffentlicht ...

edit: hat mit Hilfe von Value Ink ein paar Bytes entfernt:

->a{(r=0...a.size).max_by{|i|a[i]?0:r.map{|j|a[j]?(i-j).abs: 0}.reduce(:+)}}

Es ist eine anonyme Funktion, die eine Reihe wahrer / falscher Werte annimmt, wie zum Beispiel:

f=->->a{(r=0...a.size).max_by{|i|a[i]?0:r.map{|j|a[j]?(i-j).abs: 0}.reduce(:+)}}
# Test case number 5:
p f[[1, 1, 1, 1, nil, nil, nil, nil, nil, nil, 1]] # => 9

Mathematica, 53 Bytes

MaximalBy[a=PositionIndex@#;a@0,Tr@Abs[#-a@1]&][[1]]&

Verwendet 1-basierte Indizierung und nimmt Eingaben als Liste von 0s und 1s entgegen.

Javascript ES6 - 98 95 91 86 84 88 Bytes

Bearbeiten: Scheint, dass der Stall ganz links im Falle eines Unentschieden verwendet werden sollte. Quadratische Abstände funktionieren nicht mehr, zurückgesetzt auf absolute Distanz.

(r,x=0,f=g=>r.reduce(g,0))=>f((p,o,i)=>x<(o=f((p,c,j)=>p+c*!o*Math.abs(i-j)))?(x=o,i):p)

Ungolfed:

(r,                            // string input
 x=0,                          // current max distance
 f=g=>r.reduce(g,0))=>         // iterator function
   f((p,o,i)=>                 // for each stall
     x<(o=f((p,c,j)=>          // iterate through all stalls and
       p+c*!o*Math.abs(i-j)))? //   calculate sum of distances from current stall
     (x=o,i):                  // if total dist is greater than x, update x, return index
     p)                        //   else return previous max index

Testläufe:

f=(r,x=0,f=g=>r.reduce(g,0))=>f((p,c,i)=>x<(c=+c?0:f((p,c,j)=>p+c*Math.abs(i-j)))?(x=c,i):p)
f([1,0,1])                   // 1
f([0,0,1,0,1,1])             // 0
f([1,0,1,0,0,0,0,1,1])       // 1
f([1,0,0,0,0,0,1,1,0,0,0,0]) // 11
f([1,1,1,1,0,0,0,0,0,0,1])   // 9
f([1,0])                     // 1

Lua, 165 150 Byes

n=arg[1]n=n:gsub("%|%-","1"):gsub("%| ","0")i=0 for s in n:gmatch("0+")do i=(i<#s)and(#s)or(i)end n,l=n:find(("0"):rep(i))print(n+math.floor((l-n)/2))

Dies schummelt ein wenig, weil lua im Allgemeinen eine Tabelle mit dem Namen arg übergibt, die alle Kommandozeilen-Eingaben enthält.

Ich bin ein bisschen enttäuscht, dass ich eine for-in-Schleife verwendet habe, aber ich konnte mir keinen kleineren Weg vorstellen, um das zu schaffen.

Da lua auch 1-basierte Indizierung verwendet wurde.

Edit Snipped 15 Bytes von einem verschwenderischen gsub.

C #, 127 Bytes

public int G(char[]s){int i=0;var l=s.ToLookup(b=>b,b=>i++);return l['0'].OrderBy(j=>l['1'].Average(p=>Math.Abs(p-j))).Last();}

Prüfstand

public static void Main() {
    var respectful = new Respectful();
    foreach (var kvp in testCases) {
        $"{kvp.Key}: Expected {kvp.Value} Actual {respectful.G(kvp.Key.ToCharArray())}".Dump();
    }
}

public static readonly List<KeyValuePair<string, int>> testCases = new List<KeyValuePair<string, int>> {
    new KeyValuePair<string, int>("101", 1),
    new KeyValuePair<string, int>("001011", 0),
    new KeyValuePair<string, int>("101000011", 1),
    new KeyValuePair<string, int>("100000110000", 11),
    new KeyValuePair<string, int>("11110000001", 9),
    new KeyValuePair<string, int>("10", 1),
    new KeyValuePair<string, int>("1001", 1),
};

public class Respectful {
    public int G(char[]s){int i=0;var l=s.ToLookup(b=>b,b=>i++);return l['0'].OrderBy(j=>l['1'].Average(p=>Math.Abs(p-j))).Last();}
}