在洗手间要尊重


35

当然,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

这是,因此以字节为单位的最短代码胜出!

您可以在答案中使用基于0或1的索引。如果您使用基于1的索引,那么您必须在答案中明确指出。


35
当然,SE网络非常了解如何在洗手间受到尊重 ” [需引文]
Alex A.

7
@AlexA .:看一下travel.stackexchange 上的厕所问题和答案,以评估SE网络的教育水平(或进行自我教育)。
乔纳斯(Jonas)

30
但是每个人都知道,尊重标准是使最小距离最大化,而不是使平均距离最大化:-)
路易斯·门多

2
@Dopapp您应该添加[1,0,0,1]为测试用例。当前的测试用例都无法验证是否正确断开了联系。
丹尼斯

8
为什么101000011返回1(而不是4或5)?
Amani Kilumanga '16

Answers:


11

果冻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.

我相信这是9个字符,而不是9个字节。
勒内Nyffenegger

Jelly使用了一个自定义代码页,该页将唯一理解的字符编码为一个字节。标头中的字节链接指向它。
丹尼斯

我没有意识到这一点...感谢您指出这一点。
雷内·尼芬格

@Dennis您是否创建了自动注释用户脚本,所以您只需单击“果冻字节注释”,它就会发布它?
NoOneIsHere

@NoOneIsHere我确实有该用户脚本(不是我的用户脚本),但是我尚未添加此用户脚本。我可能应该...-
丹尼斯

6

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

2
我喜欢快速的答案
downrep_nation

学习很有趣:)尽管它往往是打高尔夫球的一种非常痛苦的语言。标准库确实是最小的(您打算在大多数时间使用Foundation),该语言具有很高的表达力,并且是静态类型的。闭包语法确实非常好
Alexander

我可能应该解释一下这段代码的工作原理
亚历山大(Alexander)

1
@downrep_nation如果您感兴趣的话,我添加了无高尔夫球的绒毛
亚历山大

也许通过删除“ let” idk来节省3个字节(如果确实需要),但是据我了解,您不需要“ let”,后者仅用作恒定值的指标
Rohan Jhunjhunwala

5

果冻,13 个字节

1个索引。

³Tạ⁸S
JUÇÞḟTṪ

在线尝试!

算法

天真地执行这个问题。


大声笑比我的答案短16倍+ 1!(1!== 1)
Rohan Jhunjhunwala 2016年

@RohanJhunjhunwala你怎么说?
Leaky Nun

本质上,Java永远无法与Jelly竞争。看到12字节长(比任何可能的Java程序都短)的答案很有趣。所以有一个upgoat ..
罗汉Jhunjhunwala

@LeakyNun哈哈错过了高尔夫:D
Rohan Jhunjhunwala

2
1001在应返回2时输出3
Daniel

5

Java的“只有” 270 200 196 187 196 138 148 146字节!

感谢Leaky Nun 节省了4 13 13个无数字节!1个字节,感谢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;}

不打高尔夫球

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表示打开停顿。


评论不作进一步讨论;此对话已转移至聊天
Alex A.

您不需要数组a
Leaky Nun

@LeakyNun如何删除它?
Rohan Jhunjhunwala

通过在一次迭代中找到最小值(结合外部for循环)
Leaky Nun

哦,@ LeakyNun今天回到我的身边将会做
Rohan Jhunjhunwala

4

Ruby,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}

1
0...~/$/是一个很好的把戏。👍🏻–
约旦

2

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

2

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是在开始时添加的,但这只是为了在多个条目上对其进行测试。


我数+7F'' alp-不计入。
NoOneIsHere

@NoOneIsHere Hum,确实,那将是我的坏事。谢谢
达达

2

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的索引。
像其他答案一样,最大化总距离而不是平均距离。
可能还有更多打高尔夫球的可能...


2

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

接受一个布尔数组(真/假或1/0)。因为它们都使用相同的公因子,所以没有点可以计算平均距离,因此只需计算每个档位的总距离并找到最高档位的第一个索引即可。编辑:通过使用*代替保存了1个字节&&。通过基于@Dendrobium的注释手动找到最大距离,节省了5个字节。u根据@ edc65的注释,通过重新用作伪减少累加器来节省7个字节。


79个字节:a=>(x=0,a.map((o,i)=>x<(t=a.reduce((r,u,j)=>r+(b=i-j)*b*u*!o,0))&&(x=t,r=i)),r)
石斛

@Dendrobium这个问题要求绝对距离;您似乎正在计算RMS距离。
尼尔

1
使用数组作为输入-好主意。计算总数而不是平均值-好主意。使用reduce代替map- MMMM
edc65

75:s=>s.map((u,i)=>u||(s.map((w,j)=>u-=w*Math.abs(j-i)),u<x&&(x=u,r=i)),x=0)|r
edc65 '16

@Neil不太RMS,只是平方距离,这应该不会影响解决方案的结果,除非有(例如在非对称的投入总距离关系1100011101的纽带28使用绝对时,8使用方时),而不是它,因为重要的似乎规则已经澄清,现在与最左边的摊位之间的关系已得到解决...
Dendrobium


1

Ruby,87 76个字节

迅速将这份初稿放在一起,但与此同时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

1
将初始范围分配给变量(r=0...a.size),然后在其上映射,而不使用with_indexr.map{|j|a[j]?(i-j).abs: 0}。这应该为您提供78个字节。
价值墨水

@ValueInk太好了,谢谢!仅使用功能,没有分配,我得到76个字节
daniero

1

Mathematica,53个字节

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

使用基于1的索引,并将输入作为0和1的列表。


0

的Javascript 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

0

Lua中,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))

通常,lua会传递一个名为arg的表,该表包含任何命令行输入,这有点欺骗。

我对for in循环感到失望,但我想不出一种更小的方法来实现它。

另外,由于lua,使用了基于1的索引。

编辑浪费的gsub中的15个字节。


0

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();}
}
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.