长跑赛车


18

系统将为您提供两个输入:一个以游程长度编码格式定义运行轨迹的字符串,以及一个大写字母,表示从其开始的车道。例如,字符串“ 3a4A6b5B”扩展为“ aaaAAAAbbbbbbBBBBBBB”。然后,使用扩展的字符串来创建轨道,如下所示:

 A) aaaAAAA
 B) bbbbbbBBBBB

这是一条有两条车道的赛道。小写字母代表空气。你不能在空中跑!大写字母表示可以行驶的道路。您的挑战目标是给定大写字母,输出从该车道开始行驶的赛车手能跑多远。如果赛车正上方或正下方有一条道路,则允许赛车手转换车道。他们也被允许倒退!在此特定轨道上,任何字母输入的输出均为0,因为这两个轨道都在位置1处没有可行驶的道路。

例子:

输入: “ 4A5B4c3C”,“ A”

此代码扩展为如下所示的轨道:

A) AAAA
B) BBBBB
C) ccccCCC

此示例的输出为7,因为从车道A开始的跑步者可以向下移动至车道B,然后下降至车道C,最后到达第7位。

输入: “ 4A2B3D”,“ D”

跟踪:

A) AAAA
B) BB
C)
D) DDD

输出为3,因为从D道开始的跑步者无法进入B道或A道

输入: “ 4A4a4A3b6B5C”,“ A”

跟踪:

A) AAAAaaaaAAAA
B) bbbBBBBBB
C) CCCCC

输出为12,因为A上的跑步者可以切换到B,然后最后返回A。“ C”的最大距离也是12。对于“ B”,最大距离是0。

输入: “ 12M4n10N11O”,“ M”

跟踪:

M) MMMMMMMMMMMM
N) nnnnNNNNNNNNNN
O) OOOOOOOOOOO

具有多位游程长度的简单示例。输出为14

输入: “ 4A5B1b2B4c3C”,“ A”

跟踪:

A) AAAA
B) BBBBBbBB
C) ccccCCC

输出为8,因为A处的跑步者可以下降到B,然后下降到C,然后返回到B。(对于本示例,感谢FryAmTheEggman。)

输入: “ 1a2A2a2B1c1C1d3D”,“ B”

跟踪:

A)aAAaa
B)BB
C)cC
D)dDDD

输出为4。跑步者必须检查两条路径,然后看哪条路更远。(对于本示例,感谢user81655。)

输入: “ 2A1b1B2C1D3E”,“ A”

跟踪:

A) AA
B) bB
C) CC
D) D
E) EEE

输出为3。您必须向后跑才能到达最远的目的地。(再次感谢本示例的user81655。)

笔记:

  • 如果轨道在某个位置没有字母,则也算作空气。这样,如果输入为“ Q”,并且尚未在车道“ Q”上放置任何道路,则输出应为0
  • 有两个输入。第一个是游程长度编码的字符串。第二个是大写字母(您可以使用string或char数据类型。)为了便于阅读,这些输入之间应该有一些合理的分隔符(空格,换行,制表符,逗号,分号)。
  • 运行长度编码的字符串将始终按字母顺序列出元素
  • 一条车道的最长长度可以是1000。因此,最大可能的输出是1000。

轨道生成器:

为了纪念我们的第一个答案,这里提供了一个轨道生成器。尝试提出一些问题以解决当前的问题!(注意:仅因为生成器未显示错误消息并不表示您的跟踪代码一定有效。请参见上面的示例以获取正确的格式。)

function reset() {
    var t = document.getElementById("track");
    t.innerHTML = "";
    for(var i = 0;i<26;i++) {
      var c = String.fromCharCode(i+65);
      t.innerHTML += "<div><span>"+c+") </span><span id='"+c+"'></span></div>";
      
    }
  }

function rand() {
  var track = "";
  for(var i = 0;i<26;i++) {
  var blocks = Math.floor(Math.random()*4);
  var start = Math.floor(Math.random()*2);
  for(var j = 0;j<blocks;j++) {
    var letter = String.fromCharCode(65+i+32*((start+j)%2));
    var length = Math.floor(Math.random()*4)+1;
    track += length+letter;
  }
  }
  document.getElementById("code").value = track;
}

  function gen() {
  var s = document.getElementById("code").value;
    var check = s.match(/(\d+[A-Za-z])+/);
    if(check == null || check[0]!=s) {
      alert("Invalid Track");
      return false;
    }
    reset();
  var n = s.match(/\d+/g);
    var o = s.match(/[A-Za-z]/g);
    for(var i = 0;i<n.length;i++) {
      var c = o[i].toUpperCase();
      document.getElementById(c).textContent += o[i].repeat(n[i]);
    }
    return true;
    }
<body onload="reset()">
Track: <input type="text" id="code" size="75%" /><input type="submit" onclick="gen()" /><input type="button" value="Random Track" onclick="rand()" /><code id="track"/>
  </body>


3
随着切换的决策和向后的运行,它比现在的轨迹更像是迷宫:P
user81655

是否只有一种途径-如在测试案例中一样?
RichieAHB 2015年

@RichieAHB可能有多个路线。
geokavel 2015年

只想知道是否4A2B3D可以消除处理丢失的C in的复杂性?例如,添加0c?如果不是,那么在1A1Z给出提示后,是否应假定存在车道BY(但为空)?
肯尼2015年

1
而且,向后运行是一个巨大的问题。该12M4n10N11O示例中,输出14,然后是假:在M0的最长路径的开始和结束在C0,为25的长度
肯尼

Answers:


3

Perl中,231个 219 203 192 189字节

为包括+1 -p

sub f{my($l,$p,$m)=@_;map{$m=$_>$m?$_:$m}f($l,$p+1)+1,f($l-1,$p),f($l+1,$p),f($l,$p-1)-1if$L[$l][$p]&&!$V{$l}{$p}++;$m}s/(\d+)(.)\s*/push@{$L[ord$2&~32]},(0|$2lt'a')x$1;()/ge;$_=0|f(ord,0)

少打高尔夫球:

sub f{                          # this is a recursive function, so we need locals.
    my($l,$p,$m)=@_;            # in: lane, position; local: max path length

    map{
      $m = $_ > $m ? $_ : $m    # update max
    }
    f( $l,   $p+1 )+1,          # same lane, forward
    f( $l-1, $p   ),            # left lane, same pos
    f( $l+1, $p   ),            # right lane, same pos
    f( $l,   $p-1 )-1           # same lane, backtrack
    if
        $L[$l][$p]              # check if there's road here
    && !$V{$l}{$p}++            # and we've not visited this point before.
    ;

    $m                          # return the max
}

s/(\d+)(.)\s*/                  # Parse RLE pattern, strip starting lane separator
  push@{ $L[ord$2&~32] }        # index @L using uppercase ascii-code, access as arrayref
  ,(0|$2lt'a')x$1               # unpack RLE as bitstring
  ;()                           # return empty list for replacement
/gex;                           # (x for ungolfing)
                                # $_ now contains trailing data: the start lane.

$_ =                            # assign output for -p
   0|                           # make sure we print 0 instead of undef/nothing
   f(ord,0)                     # begin calculation at start of current lane

跑步

上面代码存储在一个文件中(例如231.pl)。输入形式为(\d+\w)+ *\w。示例:输入轨迹4A5B4c3C和车道A

echo 4A5B4c3C A | perl -p 231.pl

测试套件

(不打高尔夫球)

printf "==== Testing %s\n", $file = shift // '231.pl';

sub t{
    my($input,$expect) = @_;
#   $input =~ s/\s//g;
    printf "TEST %-20s -> %-3s: ", $input, $expect;

    $output = `echo $input | perl -p $file`;

    printf "%-3s  %s\n", $output,
    $output == $expect
    ? " PASS"
    : " FAIL: $output != $expect";

}

t("4A5B4c3C A", 7);
t("4A5B4c3C C", 0);
t("4A2B3D D", 3);
t("4A4a4A3b6B5C A", 12);
t("4A4a4A3b6B5C B",  0);
t("4A4a4A3b6B5C C", 12);
t("12M4n10N11O M", 14 );
t("4A5B1b2B4c3C A", 8);
t("1a2A2a2B1c1C1d3D B", 4 );
t("2A1b1B2C1D3E A", 3 );
t("10A9b1B8c2C9D1E11F A", 11);
  • 更新219通过重新整理数组索引来节省12个字节。
  • 更新203通过重构递归节省16个字节。
  • 更新192通过消除@L=map{[/./g]}@L后处理节省了11个字节。
  • 更新189通过if使用后缀map代替来节省3个字节for

我不是这是Perl的事情,但是运行FAST。
geokavel 2015年

6

的JavaScript(ES6),298个 334字节

(t,s)=>[a=[],t.match(/\d+(.)(\d+\1)*/gi).map(l=>a[c=l.match`[A-Z]`+"",n=c.charCodeAt(),c==s?i=n:n]=l[r="replace"](/\d+./g,p=>(p.slice(-1)<"a"?"1":"0").repeat(parseInt(p))),i=o=-1),...a.join``,a[i]?a[i]=a[i][r](/^1/,2):0].map(_=>a.map((l,y)=>a[y]=l[r](/1/g,(c,x)=>((a[y-1]||s)[x]|(a[y+1]||s)[x]|l[x-1]|l[x+1])>1?(x>o?o=x:0,2):c)))&&o+1

说明

基本上,此解决方案将轨道视为迷宫。它找到跑步者可能到达的所有平铺位置,并返回找到的X索引的最大值。

它要做的第一件事是将输入字符串解码为行数组。但是,它不使用字母,而是将大写字母变为a 1,将小写字母变为a 0。生成的地图将如下所示:

11100011
0011100
100111

之后,它将起始磁道的第一个图块设为a 2(仅当它已经存在时1),并循环遍历每个图块,检查相邻图块是否为2。如果a 与之1相邻,2则变为2。如果跑步者从第一行开始,则上面的地图将变为:

22200011
0022200
100222

a的最高X索引2成为结果。

当我做这个的最初版本时,我做了一个很小的疏忽,并且花了我36个字节来破解它,直到它起作用为止,因此,对此可能会有很多改进。*叹*

不打高尔夫球

(t,s)=>
  [

    // Decode run-length encoded string into an array of track lanes
    a=[],                           // a = array of track line strings, 0 = air, 1 = tiles
    t.match(/\d+(.)(\d+\1)*/gi)     // regex magic that separates pairs by their letter
    .map(l=>                        // for each line of pairs
      a[                            // add the tiles to the array
        c=l.match`[A-Z]`+"",        // c = pair character
        n=c.charCodeAt(),           // n = index of line
        c==s?i=n:n                  // if this line is the starting line, set i
      ]=l[r="replace"](/\d+./g,p=>  // match each pair, p = pair
        (p.slice(-1)<"a"
          ?"1":"0").repeat(         // repeat 0 for air or 1 for ground
            parseInt(p)             // cast of match would return NaN because of the
          )                         //     letter at the end but parseInt works fine
      ),
        i=                          // i = index of starting line, initialise as invalid
          o=-1                      // o = output (max value of x)
    ),

  // Find all positions that are possible for the runner to get to
    ...a.join``,                   // add every letter of the track lines to an array
    a[i]?a[i]=a[i][r](/^1/,2):0    // set the starting tile to 2 if it is already 1
  ].map(_=>                        // loop for the amount of tiles, this is usually way
                                   //     more than necessary but allows for hard to reach
                                   //     tiles to be parsed
    a.map((l,y)=>                  // for each line l at index y
      a[y]=l[r](/1/g,(c,x)=>       // for each character c at index x

        // Replace a 1 with 2 if there is a 2 to above, below, left or right of it
        ((a[y-1]||s)[x]|(a[y+1]||s)[x]|l[x-1]|l[x+1])>1?
          (x>o?o=x:0,2):c          // set o to max value of x for a 2 tile
      )
    )
  )
  &&o+1                            // return o + 1

测试

奖励:输出包括已解析的地图!

var solution = (t,s)=>[a=[],t.match(/\d+(.)(\d+\1)*/gi).map(l=>a[c=l.match`[A-Z]`+"",n=c.charCodeAt(),c==s?i=n:n]=l[r="replace"](/\d+./g,p=>(p.slice(-1)<"a"?"1":"0").repeat(parseInt(p))),i=o=-1),...a.join``,a[i]?a[i]=a[i][r](/^1/,2):0].map(_=>a.map((l,y)=>a[y]=l[r](/1/g,(c,x)=>((a[y-1]||s)[x]|(a[y+1]||s)[x]|l[x-1]|l[x+1])>1?(x>o?o=x:0,2):c)))&&o+1
function generateMap() { var start = 0; a.some((l, i) => l ? start = i : 0); var end = 0; a.map((l, i) => l && i <= 90 ? end = i : 0); for(var output = "", i = start; i < end + 1; i++) output += String.fromCharCode(i) + ") " + (a[i] || "") + "\n"; return output; }
Track = <input type="text" id="track" value="2A1b1B2C1D3E" /><br />
Starting Letter = <input type="text" id="start" value="A" /><br />
<button onclick="result.textContent=solution(track.value,start.value)+'\n\n'+generateMap()">Go</button>
<pre id="result"></pre>

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.