งูมีลักษณะเช่นนี้:

      >>>v
@     ^  v
^  >>>^  v
^        v
^<<<<<<<<<

งูสามารถข้ามตัวมันเองได้ในกรณีนี้:

 @
 ^
>^>v
 ^<<

เพื่อให้ครอสโอเวอร์มีความถูกต้องตัวละครทั้งสองข้างจะต้องเคลื่อนที่ไปในทิศทางเดียวกัน กรณีของ

 @
>^v
 ^<

อาจถือว่าไม่ชัดเจนและไม่ถูกต้อง

เอาท์พุทเป็นสตริงของการWASDแสดงไปจากหัวถึงหาง ( @)

ให้งูที่ไม่ได้ย้อนรอยและไม่คลุมเครือคุณสามารถเขียนโปรแกรมที่จะแสดงผลสายการเคลื่อนไหวที่งูใช้

นี่คือรหัสกอล์ฟคำตอบที่สั้นที่สุดชนะ!

กรณีทดสอบ:

_{(หมายเหตุ: @สามารถแทนที่ด้วยอักขระใด ๆ ที่ไม่ได้อยู่ในv^<>)}

การป้อนข้อมูล:

>>>>v
    v
  v<<  @
  v    ^
  >>>>>^

เอาท์พุท: ddddssaassdddddww

การป้อนข้อมูล:

@>>v
^  v
^  v
^<<<

เอาท์พุท: dddsssaaawww

การป้อนข้อมูล:

>>>v
   v       @
   v       ^
   >>>>v   ^
       >>>>^

เอาท์พุท: dddsssddddsddddwww

การป้อนข้อมูล:

@<< v
  ^ v
v<^<<
v ^
>>^

เอาท์พุท: ssaaaassddwwwwaa

การป้อนข้อมูล:

@v<v
^v^v
^v^<
^<

เอาท์พุท: ssawwasssawww

Java, 626 539 536 529 ไบต์

-87 ไบต์โดยการบันทึกบางแห่งในหลาย ๆ ที่ ขอบคุณไปที่ Mr Public เพื่อชี้ให้เห็นบางอย่าง

-3 ไบต์เพราะฉันไม่สามารถลบช่องว่างทั้งหมดก่อนลอง (ขอบคุณ mbomb007)

+8 ไบต์เพื่อแก้ไขสำหรับกรณีนี้:

@v<v
^v^v
^v^<
^<

-15 ไบต์โดยการประกาศตัวแปรโหลดหน้า

s->{String o="",t;String[]p=s.split("\n");int h=p.length,w=p[0].length(),y=0,x,b=0,a,n,m;char[][]d=new char[h][w];for(;y<h;y++)for(x=0;x<w;x++){d[y][x]=p[y].charAt(x);if(d[y][x]=='@')d[y][x]=' ';}for(;b<h;b++)for(a=0;a<w;a++){t="";x=a;y=b;n=0;m=0;while(!(y<0|y>h|x<0|x>w||d[y][x]==' ')){if(y+m>=0&y+m<h&x+n>=0&x+n<w&&d[y+m][x+n]==d[y-m][x-n])d[y][x]=d[y-m][x-n];n=m=0;switch(d[y][x]){case'^':t+="W";m--;break;case'<':t+="A";n--;break;case'v':t+="S";m++;break;case'>':t+="D";n++;}x+=n;y+=m;}o=t.length()>o.length()?t:o;}return o;}

รุ่นที่อ่านได้:

static Function<String,String> parser = snake -> {
    // declare all variables in one place to minimize declaration overhead
    String output = "", path;
    String[] split = snake.split("\n");
    int h=split.length, w=split[0].length(), y=0, x, startY=0, startX, dx, dy;
    char[][] board = new char[h][w];
    // setup char[][] board
    for (; y<h; y++)
        for (x=0; x<w; x++) {
            board[y][x]=split[y].charAt(x);
            if(board[y][x]=='@')board[y][x]=' ';
        }
    // find the longest possible path
    for (; startY<h; startY++)
        for (startX=0; startX<w; startX++) {
            path = "";
            x=startX; y=startY; dx=0; dy=0;
            while (!(y<0 | y>h | x<0 | x>w || board[y][x] == ' ')) {
                if (y + dy >= 0 & y + dy < h & x + dx >= 0 & x + dx < w
                        && board[y + dy][x + dx] == board[y - dy][x - dx]) {
                    board[y][x] = board[y - dy][x - dx];
                } dx = dy = 0;
                switch(board[y][x]) {
                    case '^':path+="W";dy--;break;
                    case '<':path+="A";dx--;break;
                    case 'v':path+="S";dy++;break;
                    case '>':path+="D";dx++;break;
                }
                x+=dx; y+=dy;
            }
            output = path.length()>output.length()?path:output;
        }
    return output;
};

ใช้สตริงเหมือนv @\n>>>^กัน สร้างเส้นทางเริ่มต้นที่แต่ละพิกัดแล้วส่งกลับที่ยาวที่สุด Lookahead ที่จำเป็นสำหรับเส้นทางที่ทับซ้อนกันเป็นส่วนที่ยากที่สุด

ทับทิม, 217

->a{r=''
z=a.index ?@
a.tr!('<^>v',b='awds').scan(/\w/){c=0
e,n=[a[z,c+=1][?\n]?p: c,d=c*a[/.*
/].size,a[z-c,c][?\n]?p: -c,-d].zip(b.chars).reject{|i,k|!i||a[v=i+z]!=k||0>v}.max_by{|q|q&[a[z]]}until n
z+=e
r=n*c+r}
r}

สิ่งนี้เริ่มต้นที่@และเดินไปข้างหลังมองหาเพื่อนบ้านที่ชี้ไปที่ตำแหน่งปัจจุบัน ( z) ในการเลือกวิธีที่ถูกต้องที่ทางแยก 4 ทิศทางจะให้เพื่อนบ้านที่ชี้ไปในทิศทางเดียวกัน ( max_by{...}) หากไม่พบเพื่อนบ้านทันทีจะถือว่ามีการข้ามไปและเอื้อมมือออกไปทีละระดับจนกว่าจะพบหนึ่ง ( until nและc+=1) กระบวนการนี้ทำซ้ำสำหรับจำนวนเซ็กเมนต์ (ไม่รวมส่วนหัว) ( .scan(/\w/){...})

กรณีทดสอบที่ฉันเพิ่มเข้าไปในจิ๊กซอร์นั้นทำให้ฉันสะดุดดังนั้นฉันจึงขึ้นฟอร์ม 182 ตัวอักษรไปที่ 218 ตัวละครพิเศษเหล่านั้นล้วนทำให้แน่ใจว่าการเคลื่อนไหวในแนวนอนของฉันไม่ได้เข้าสู่บรรทัดถัดไป / ก่อนหน้า ฉันสงสัยว่าฉันสามารถจัดการกับมันในทางที่ดีขึ้น

Ungolfed:

f=->a{
  result=''
  position=a.index ?@ # start at the @
  a.tr!('<^>v',b='awds') # translate arrows to letters
  a.scan(/\w/){           # for each letter found...
    search_distance=0
    until distance
      search_distance+=1
      neighbors = [
        a[position,search_distance][?\n]?p: search_distance,  # look right by search_distance unless there's a newline
        width=search_distance*a[/.*\n/].size,   # look down (+width)
        a[position-search_distance,search_distance][?\n]?p: -search_distance, # look left unless there's a newline
        -width                  # look up (-width)
      ]
      distance,letter = neighbors.zip(b.chars).reject{ |distance, letter_to_find|
        !distance || # eliminate nulls
         a[new_position=distance+position]!=letter_to_find || # only look for the letter that "points" at me
         0>new_position # and make sure we're not going into negative indices
       }.max_by{ |q| 
        # if there are two valid neighbors, we're at a 4-way intersection
        # this will make sure we prefer the neighbor who points in the same 
        # direction we're pointing in.  E.g., when position is in the middle of 
        # the below, the non-rejected array includes both the top and left.
        #   v
        #  >>>
        #   v
        # We want to prefer left.
        q & [a[position]] 
        # ['>',x] & ['>'] == ['>']
        # ['v',x] & ['>'] == []
        # ['>'] > [], so we select '>'.
       }
    end
    position+=distance
    result=(letter*search_distance)+result # prepend result
  }
  result # if anyone has a better way of returning result, I'm all ears
}