Oczywiście sieć SE ma dużą wiedzę na temat tego, jak szanować w toalecie, ale dla tych z was, którzy potrzebują podsumowania, szacunek oznacza spłukiwanie toalety itp. Co najważniejsze, oznacza to korzystanie z kabiny tak daleko od innych, jak to możliwe.

Wyzwanie

Biorąc pod uwagę plan zestawu straganów ze wskazaniem, które z nich są używane jako ciąg, musisz zwrócić lub wydrukować z funkcji lub programu, w którym najbardziej szanowane miejsce do prowadzenia działalności jest.

Dane wejściowe

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

Stragany są ponumerowane w porządku rosnącym od lewej do prawej. Zawsze będzie co najmniej jeden pusty stragan. Wejście może zawierać do 50 przeciągnięć. Możesz również wziąć dane wejściowe jako tablicę lub ciąg znaków 0s i 1s lub booleans, jeśli wolisz.

Stoiska w użyciu mają -w nich (pomiędzy rurami).

Wyjście

Najbardziej szanowanym stoiskiem, na które należy przejść, jest ten, który jest średnio najdalej od używanych. Odległość między dwoma straganami jest wartością bezwzględną różnicy liczb nad nimi.

Żeby było jasne: znajdujesz średnią odległość od wszystkich straganów - nie tylko sąsiednich.

Musisz wydać najmniejszą liczbę najbardziej szacownych przeciągnięć, aby przejść do tego miejsca, które jest puste .

Przykłady

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

To jest golf golfowy , więc wygrywa najkrótszy kod w bajtach!

W odpowiedzi możesz użyć indeksowania opartego na 0 lub 1 - w zależności od tego, co wolisz; jeśli korzystasz z indeksowania 1, musisz to wyraźnie powiedzieć w swojej odpowiedzi.

Galaretka , 10 9 bajtów

JạþTS׬MḢ

Wykorzystuje indeksowanie 1. Wypróbuj online! lub zweryfikuj wszystkie przypadki testowe .

Jak to działa

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.

Swift, 158, 157, 128, 100 bajtów

Pobiera dane wejściowe ze Array<Bool>zmiennej i, zwraca odpowiedź z ostatniego wyrażenia.

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

Edycja 1:

Zapisano bajt, konwertując na boole poprzez porównanie ciągów

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

Edycja 2:

Przerobiłem mój algorytm:

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

Edycja 3:

Wykorzystano nową regułę, która pozwala pobierać dane bezpośrednio z tablicy boolowskiej.

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

Nie golfowany:

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

Galaretka , 13 bajtów

1-indeksowany.

³Tạ⁸S
JUÇÞḟTṪ

Wypróbuj online!

Algorytm

Naiwne wdrożenie pytania.

Java „tylko” 270 200 196 187 196 138 148 146 bajtów!

zaoszczędził 4 13 niezliczonych bajtów dzięki Leaky Nun! 1 bajt dzięki 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;}

Bez golfa

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

dane wejściowe jako tablica boolowska, gdzie true oznacza otwarte przeciągnięcie.

Ruby, 79 78 76 + nflaga = 77 bajtów

Dane wyjściowe jest indeksowane w oparciu o 0. Dane wejściowe to linia STDIN zera i jedynki.

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

MATL , 14 bajtów

~ftGf!-|Xs&X>)

Wypróbuj online!

Wyjście jest oparte na 1.

Wyjaśnienie

~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 ( -alpflagi) = 87 bajtów

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

Potrzebuje -alpflagi do uruchomienia. Pobiera na wejściu ciąg 1 i 0 oddzielone spacjami. Na przykład :

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"

Pamiętaj, że dodałem $m=0na początku, ale to tylko w celu przetestowania wielu wpisów.

Matlab, 87 bajtów

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

Pobiera tablicę zer i jedynek; używa indeksowania 1.
Podobnie jak niektóre inne odpowiedzi maksymalizuje całkowity, a nie średni dystans.
Prawdopodobnie jest więcej golfa ...

JavaScript (ES6), 87 86 82 75 bajtów

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

Pobiera tablicę boolowską (prawda / fałsz lub 1/0). Nie ma sensu obliczać średniej odległości, ponieważ wszyscy używają tego samego wspólnego współczynnika, więc wystarczy obliczyć całkowitą odległość dla każdego przeciągnięcia i znaleźć pierwszy indeks najwyższego. Edycja: Zapisano 1 bajt, używając *zamiast &&. Zaoszczędzono 5 bajtów poprzez ręczne znalezienie największej odległości na podstawie komentarza @Dendrobium. Zaoszczędzono 7 bajtów, ponownie wykorzystując ujako akumulator pseudo-redukcyjny na podstawie komentarza @ edc65.

J, 27 bajtów

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

Tłumacz online .

Rubin, 87 76 bajtów

Szybko zrzuciłem ten pierwszy szkic, ale w międzyczasie Value Ink opublikowało już 80-bajtową odpowiedź Ruby ...

edycja: usunął niektóre bajty z pomocą Value Ink:

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

Jest to anonimowa funkcja, która pobiera tablicę wartości prawdy / fałszu, na przykład:

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 bajty

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

Wykorzystuje indeksowanie 1 i przyjmuje dane wejściowe jako listę zer i jedynek.

JavaScript ES6 - 98 95 91 86 84 88 bajtów

Edycja: Wydaje się, że w przypadku remisu należy użyć przeciągnięcia w lewo. Kwadratowe odległości już nie działają, przywrócono do absolutnej odległości.

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

Nie golfowany:

(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

Przebiegi testowe:

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 Pa

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

To oszukuje trochę, wykorzystując fakt, że ogólnie rzecz biorąc, lua przekazuje do niej tabelę o nazwie arg zawierającą wszelkie dane wejściowe z wiersza poleceń.

Jestem trochę rozczarowany, że użyłem pętli for in, ale nie mogłem wymyślić mniejszego sposobu, aby to zrobić.

Ponadto, ponieważ zastosowano indeksowanie oparte na lua, 1.

Edytuj Snipped 15 bytes z marnotrawnego gsub.

C #, 127 bajtów

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

Łóżko testowe

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