물론 SE 네트워크는 화장실에서 존중하는 방법에 대해 잘 알고 있지만, 정리가 필요한 사람들에게는 화장실을 씻는 등의 의미가 있습니다. 가장 중요한 것은 마구간을 멀리 사용하는 것을 의미합니다. 가능한 다른 사람들로부터.

도전

어떤 스톨이 문자열로 사용되고 있는지를 나타내는 스톨 세트의 청사진이 주어지면 비즈니스에서 가장 존경받는 장소가있는 기능이나 프로그램에서 반환하거나 인쇄해야합니다.

입력

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

매점은 왼쪽에서 오른쪽으로 오름차순으로 번호가 매겨집니다. 항상 빈 스톨이 하나 이상 있습니다. 입력에 최대 50 개의 스톨이있을 수 있습니다. 원하는 경우 입력을 0s 및 1s 또는 부울 의 배열 또는 문자열로 사용할 수도 있습니다 .

사용중인 스톨 -은 파이프 사이에 있습니다.

출력

가장 존경받는 스톨은 사용중인 스톨과 평균 거리가 가장 먼 스톨입니다. 두 스톨 사이의 거리는 위의 숫자 차이의 절대 값입니다.

명확하게 말하면, 이웃 마구간뿐만 아니라 모든 마구간 에서 평균 거리를 찾는 것입니다.

가장 존경받는 스톨의 가장 적은 수를 출력해야 비어 있습니다.

예

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

이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이깁니다!

답변에 0 또는 1 기반 색인을 사용할 수 있습니다. 1 기반 인덱싱을 사용하는 경우 답변에 명시 적으로 말해야합니다.

젤리 , 10 9 바이트

JạþTS׬MḢ

1 기반 인덱싱을 사용합니다. 온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

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.

스위프트, 158, 157, 128, 100 바이트

Array<Bool>변수 에서 입력을 받고 i마지막 표현식에서 응답을 반환합니다.

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

편집 1 :

문자열 비교를 통해 부울로 변환하여 바이트를 저장했습니다.

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

편집 2 :

내 알고리즘을 재 작업했습니다.

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

편집 3 :

부울 배열에서 직접 입력 할 수있는 새로운 규칙을 활용했습니다.

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

언 골프 드 :

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

젤리 , 13 바이트

1- 색인.

³Tạ⁸S
JUÇÞḟTṪ

온라인으로 사용해보십시오!

연산

질문의 순진한 구현.

Java "전용" 270200 196187 196138148146 바이트!

Leaky Nun 덕분에 4 13 셀 수없는 바이트를 절약했습니다 ! Micheal Golfed 덕분에 1 바이트

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

언 골프

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

true는 열린 스톨을 의미하는 부울 배열로 입력됩니다.

루비, 79 78 76 + n플래그 = 77 바이트

출력은 0 기반 색인입니다. 입력은 0과 1의 STDIN 라인입니다.

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

MATL , 14 바이트

~ftGf!-|Xs&X>)

온라인으로 사용해보십시오!

출력은 1 기반입니다.

설명

~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 ( -alp플래그) = 87 바이트

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

-alp실행할 플래그가 필요 합니다. 공백으로 구분 된 1과 0의 문자열을 입력으로 사용합니다. 예를 들면 :

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"

$m=0처음에 추가 했지만 여러 항목에서 테스트하는 것입니다.

Matlab, 87 바이트

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

1과 0의 배열을 취합니다. 1 기반 인덱싱을 사용합니다.
다른 답변과 마찬가지로 평균 거리가 아닌 총 거리가 최대화됩니다.
아마도 더 많은 골프가있을 것입니다 ...

자바 스크립트 (ES6), 87 86 82 75 바이트

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

부울 배열을 취합니다 (true / false 또는 1/0). 모두 동일한 공통 요소를 사용하기 때문에 평균 거리를 계산하는 지점이 없으므로 각 스톨의 총 거리를 계산하고 가장 높은 스톨의 첫 번째 인덱스를 찾으십시오. 편집 : *대신을 사용하여 1 바이트를 저장했습니다 &&. @Dendrobium의 코멘트를 기반으로 가장 높은 거리를 수동으로 찾아 5 바이트를 절약했습니다. u@ edc65의 주석을 기반으로 의사 감소 누산기로 재사용하여 7 바이트를 절약했습니다.

J, 27 바이트

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

온라인 통역사 .

루비, 87 76 바이트

이 첫 번째 초안을 함께 빨리 but지만 그 동안 Value Ink 는 이미 80 바이트 Ruby 답변을 게시했습니다 ...

편집 : Value Ink의 도움으로 일부 바이트를 벗어났습니다.

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

예를 들어 다음과 같이 진실 / 거짓 값의 배열을 취하는 익명 함수입니다.

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

수학, 53 바이트

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

1 기반 인덱싱을 사용하고 0과 1의 목록으로 입력을받습니다.

자바 스크립트 ES6 - 98 95 91 86 84 88 바이트

편집 : 넥타이의 경우 가장 왼쪽에있는 스톨을 사용해야하는 것으로 보입니다. 제곱 거리가 더 이상 작동하지 않고 절대 거리로 되돌아갔습니다.

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

언 골프 드 :

(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

시운전 :

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

루아, 165 150 부전승

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

루아는 일반적으로 루아가 명령 행 입력을 포함하는 arg라는 테이블을 전달한다는 사실을 사용하여 약간의 부정 행위를합니다.

나는 for 루프를 사용했다는 것에 약간 실망했지만, 더 작은 방법을 생각할 수 없었습니다.

또한 lua이기 때문에 1 기반 인덱싱이 사용되었습니다.

쓸모없는 gsub에서 스니핑 된 15 바이트를 편집하십시오.

C #, 127 바이트

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

테스트 베드

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