Bien sûr, le réseau SE sait très bien comment être respectueux dans les toilettes, mais pour ceux d'entre vous qui ont besoin d'une récapitulation, être respectueux signifie tirer la chasse aux toilettes, etc. d'autres que possible.

Le défi

Étant donné le plan d'un ensemble de stands avec des indications de ceux utilisés comme chaîne, vous devez retourner ou imprimer à partir d'une fonction ou d'un programme où le lieu le plus respectueux pour faire de votre entreprise est.

L'entrée

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

Les stands sont numérotés dans l'ordre croissant de gauche à droite. Il y aura toujours au moins un stand vide. Il peut y avoir jusqu'à 50 stalles dans une entrée. Vous pouvez également prendre l'entrée comme un tableau ou une chaîne de 0s et 1s ou de booléens si vous préférez le faire.

Les stands en cours d'utilisation ont -entre eux (entre les tuyaux).

Le résultat

Le décrochage le plus respectueux est celui qui est en moyenne le plus éloigné de celui utilisé. La distance entre deux stalles est la valeur absolue de la différence des nombres au-dessus d’eux.

Soyons clairs: vous trouvez la distance moyenne entre tous les stands et pas seulement les voisins.

Vous devez sortir le nombre le plus bas du décrochage le plus respectueux, vide .

Exemples

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

C'est du code-golf , donc le code le plus court en octets gagne!

Vous pouvez utiliser une indexation basée sur 0 ou 1 dans votre réponse - celle que vous préférez; Si vous utilisez une indexation basée sur 1, vous devez l'indiquer explicitement dans votre réponse.

Gelée , 10 à 9 octets

JạþTS׬MḢ

Utilise l'indexation basée sur 1. Essayez-le en ligne! ou vérifier tous les cas de test .

Comment ça marche

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.

Rapide, 158, 157, 128, 100 octets

Prend l'entrée de la Array<Bool>variable i, retourne la réponse de la dernière expression.

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

Modifier 1:

Enregistré un octet en convertissant en bools via une comparaison de chaîne

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

Edit 2:

Retravaillé mon algorithme:

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:

Profiter de la nouvelle règle qui permet de prendre directement l’entrée d’un tableau booléen.

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)

Gelée , 13 octets

1 indexé.

³Tạ⁸S
JUÇÞḟTṪ

Essayez-le en ligne!

Algorithme

Mise en œuvre naïve de la question.

Java "seulement" 270 200 196 187 196 138 138 146 146 octets!

sauvé 4 13 innombrables octets grâce à Leaky Nun! 1 octet grâce à 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;
}

entrée sous forme de tableau booléen où true implique un décrochage ouvert.

Ruby, 79 78 76 + nflag = 77 octets

La sortie est une indexation basée sur 0. L'entrée est la ligne STDIN de 0 et de 1.

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

MATL , 14 octets

~ftGf!-|Xs&X>)

Essayez-le en ligne!

La sortie est basée sur 1.

Explication

~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 ( -alpdrapeaux) = 87 octets

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

A besoin de -alpdrapeaux pour courir. Prend une chaîne de 1 et 0 séparés par des espaces en entrée. Par exemple :

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"

Notez que j'ai ajouté $m=0au début, mais ce n'est que pour le tester sur plusieurs entrées.

Matlab, 87 octets

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

Prend un tableau de uns et de zéros; utilise l'indexation basée sur 1.
Comme certaines autres réponses maximise la distance totale et non moyenne.
Probablement il y a un peu plus de golf possible ...

JavaScript (ES6), 87 86 82 75 octets

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

Prend un tableau booléen (vrai / faux ou 1/0). Aucun point ne calcule la distance moyenne puisqu'ils utilisent tous le même facteur commun. Il suffit donc de calculer la distance totale pour chaque stand et de trouver le premier indice du plus élevé. Edit: 1 octet enregistré en utilisant à la *place de &&. Vous avez enregistré 5 octets en recherchant manuellement la distance la plus élevée sur la base d'un commentaire de @Dendrobium. Sauvegardé 7 octets en réutilisant ucomme accumulateur de pseudo-réduction basé sur un commentaire de @ edc65.

J, 27 octets

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

Interprète en ligne .

Ruby, 87 76 octets

Lança rapidement ce premier brouillon, mais entre-temps, Value Ink avait déjà posté une réponse Ruby de 80 octets ...

edit: a enlevé quelques octets avec l'aide de Value Ink:

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

C'est une fonction anonyme qui prend un tableau de valeurs de vérité / fausseté, comme par exemple:

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 octets

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

Utilise l'indexation basée sur 1 et utilise les entrées sous forme de liste de 0 et de 1.

Javascript ES6 - 98 95 91 86 84 88 octets

Edit: Il semble que le décrochage le plus à gauche devrait être utilisé en cas d'égalité. Les distances carrées ne fonctionnent plus, elles sont redevenues des distances absolues.

(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

Tests effectués:

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

Cela trompe un peu en utilisant le fait que généralement, lua passe une table appelée arg contenant toutes les entrées de ligne de commande.

Je suis un peu déçu d’avoir utilisé une boucle in, mais je ne pouvais pas penser à un moyen plus simple de la réussir.

Aussi, comme lua, 1 indexation basée a été utilisée.

Éditez Snipped 15 octets d'un gsub inutile.

C #, 127 octets

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

Banc d'essai

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