Код Гольф: Призрачная нога

Соревнование

Самый короткий код по количеству символов, который выведет числовое решение с учетом числа и действительного строкового шаблона, используя метод Ghost Leg.

Примеры 

Вход: 3,
"| | | | | | | |
 |-| |=| | | | |
 |-| | |-| |=| |
 | |-| |-| | |-|"

Выход: 2

Вход: 2,
"| | |=| | -| |-| |
 | |-| | |"

Выход: 1

Разъяснения

  1. Не заморачивайтесь с вводом. Рассмотрим значения, данные в другом месте.
  2. Оба входных значения действительны: номер столбца соответствует существующему столбцу, а шаблон содержит только символы |, -, = (и [пробел], [LF]). Кроме того, два соседних столбца не могут содержать тире (в одной строке).
  3. Размеры рисунка неизвестны (мин. 1х1).

Разъяснения № 2

  1. Есть два недопустимых образца: |-|-| а также |=|=| которые создают двусмысленность. Данная входная строка никогда не будет содержать их.
  2. Входные переменные одинаковы для всех; числовое значение и строка, представляющая образец.
  3. Участники должны произвести функцию.

Прецедент 

Данный шаблон:
"| - | | = | - | = | LF | | - | | | - | LF | = | | - | | | LF | | | - | = | - |"

| - | | = | - | = |
| | - | | | - |
| = | | - | | |
| | | - | = | - |

Заданное значение: ожидаемый результат
 1: 6
 2: 1 
 3: 3
 4: 5
 5: 4
 6: 2

Изменить: исправлены ожидаемые результаты

Источник

6 ответов

Решение

JavaScript: 169 158 148 141 127 125 123 122 символов


Minified и Golff:

function g(n,s){for(l=s.split('\n'),n*=2;k=l.shift();)for(j=3;j;)n+=k[n-3]==(c=--j-1?'=':'-')?-2:k[n-1]==c?2:0;return n/2}


Читаемая версия:

function g(n, str) {
   var c, i, j;
   var lines = str.split('\n');
   n = (n * 2) - 2;

   for (i = 0; i < lines.length; i++) {
      for (j = 0; j < 3; j++) {
         c = (j == 1) ? '-' : '=';

         if (lines[i].charAt(n-1) == c) n-=2;          // Move left
         else if (lines[i].charAt(n+1) == c) n+=2;     // Move right
      }
   }

   return 1+n/2;
}


Объяснение:

  1. str разбивается на массив строк.
  2. n масштабируется, чтобы охватить количество символов в каждой строке, начиная с 0.
  3. Повторяйте три раза по каждой строке: один раз для каждого слоя. Представьте, что каждая линия разделена на 3 слоя: верхний и нижний слои, где расположены ножки = знак прилагается. Средний слой для ног - приметы.
  4. Переехать n влево или вправо в соответствии с соседними знаками. Существует только один возможный ход для каждого слоя каждой линии. Следовательно n может двигаться до 3 раз подряд.
  5. Вернуть n, нормализовано, чтобы начать с 1 до количества вертикальных линий.


Тестовые случаи:

var ghostLegs = [];

ghostLegs[0] = "|-| |=|-|=|\n" +
               "| |-| | |-|\n" +
               "|=| |-| | |\n" +
               "| | |-|=|-|";

ghostLegs[1] = "| | | | | | | |\n" +
               "|-| |=| | | | |\n" +
               "|-| | |-| |=| |\n" +
               "| |-| |-| | |-|";

ghostLegs[2] = "| | |=| |\n" +
               "|-| |-| |\n" +
               "| |-| | |";

ghostLegs[3] = "|=|-|";

for (var m = 0; m < ghostLegs.length; m++) {
   console.log('\nTest: ' + (m + 1) + '\n');

   for (var n = 1; n <= (ghostLegs[m].split('\n')[0].length / 2) + 1; n++) {
      console.log(n + ':' + g(n, ghostLegs[m]));
   }
}


Результаты:

Test: 1
1:6
2:1
3:3
4:5
5:4
6:2

Test: 2
1:1
2:3
3:2
4:4
5:5
6:6
7:8
8:7

Test: 3
1:3
2:1
3:4
4:2
5:5

Test: 4
1:3
2:2
3:1
Источник

AWK - 68 77 79 символов

В значительной степени перевод решения Даниэля (мы любим тебя, парень;)

{for(i=0;i<3;){s=++i-2?"=":"-";if(s==$x)x--;else if(s!=$++x)x--}}END{print x}

Но мы можем покончить с if/else и заменить его на ?:

{for(i=0;i<3;){s=++i-2?"=":"-";s==$x?x--:s!=$++x?x--:x}}END{print x}

Запустите его с начальной позицией, определенной как переменная x:

$ for x in `seq 6`; do echo $x\ ;awk -F\| -vx=$x -f ghost.awk<<__EOF__
|-| |=|-|=|
| |-| | |-|
|=| |-| | |
| | |-|=|-|
__EOF__
done

1 6
2 1
3 3
4 5
5 4
6 2
Источник

Рубин - 66 95 92 83 символа

(Идея чередующихся строк из ответа Даниила)

def f s,m
m.each_line{|r|%w{= - =}.map{|i|s+=i==r[2*s-3]?-1:i==r[2*s-1]?1:0}}
s
end

92 символа

def f s,m
  s=s*2-2
  m.each_line{|r|%w{= - =}.each{|i|s+=i==r[s-1]?-2:i==r[s+1]?2:0}}
  1+s/2
end

использование

map="|-| |=|-|=|
| |-| | |-|
|=| |-| | |
| | |-|=|-|"

1.upto(6) do |i|
    p f(i, map)
end

Выход

6
1
3
5
4
2
Источник

Perl, 92 91 символ

sub g{for$s(pop=~/.+/g){map$_[0]-=1-abs(index substr(" $s",$_[0]*2-2,3),$_),qw[= - =]}pop}

Другой подход, 98 97 95 94 93 92 символов

sub g{map{for$s(qw[= - =]){pos=$_[0]*2-2;$_[0]+=/\G((?<=$s)|.$s)/&&$&cmp$"}}pop=~/.+/g;pop}

Тестирование

$s=<<'__PATTERN__';
|-| |=|-|=|
| |-| | |-|
|=| |-| | |
| | |-|=|-|
__PATTERN__

for $n (1..6) {
    print g($n,$s);
}
Источник

Ответ Даниэля на C# - 173 символа

Увидев решение Даниэля Вассалло, мне стало слишком стыдно, чтобы опубликовать его. Но вот ответ Даниэля, перенесенный на C#, черт возьми. Одним из основных недостатков в C# была необходимость проверки границ, которая стоила 20 символов.

int G(string s,int n){var l=s.Split('\n');n*=2;for(int i=0,j,c;i<l.Length;i++)
for(j=0;j<3;n+=n>2&&l[i][n-3]==c?-2:n<l[i].Length&&l[i][n-1]==c?2:0)c=j++==1?45
:61;return n/2;}

отформатирован:

int G(string s, int n)
{
    var l = s.Split('\n');
    n *= 2;

    for (int i = 0, j, c; i < l.Length; i++)
        for (j = 0; j < 3; n += n > 2 && l[i][n - 3] == c ? -2 : n < l[i].Length && l[i][n - 1] == c ? 2 : 0)
            c = j++ == 1 ? 45 : 61;

    return n / 2;
}
Источник

VB.Net: 290 символов (320 байт)

Требуется опция "Строгое выключено", опция "Явное выключено"

Function G(i,P)
i=i*2-1
F=0
M="-"
Q="="
Z=P.Split(Chr(10))
While E<Z.Length
L=(" "& Z(E))(i-1)
R=(Z(E)&" ")(i)
J=L & R=" "&" "
E-=(F=2Or J)
i+=If(F=1,2*((L=M)-(R=M)),If(F=2,2*((L=Q)-(R=Q)),If(J,0,2+4*(L=Q Or(L=M And R<>Q)))))
F=If(F=1,2,If(F=2,0,If(J,F,2+(L=Q Or R=Q))))
End While
G=(i-1)\2+1
End Function

Читаемая форма:

Function G(ByVal i As Integer, ByVal P As String) As Integer

    i = i * 2 - 1
    Dim F As Integer = 0
    Const M As String = "-"
    Const Q As String = "="
    Dim Z As String() = P.Split(Chr(10))
    Dim E As Integer = 0

    While E < Z.Length
        Dim L As Char = (" " & Z(E))(i - 1)
        Dim R As Char = (Z(E) & " ")(i)
        Dim J As Boolean = L & R = " " & " "

        E -= (F = 2 Or J)
        i += If(F = 1, 2 * ((L = M) - (R = M)), _
                If(F = 2, 2 * ((L = Q) - (R = Q)), _
                If(J, 0, 2 + 4 * (L = Q Or (L = M And R <> Q)))))

        F = If(F = 1, 2, If(F = 2, 0, If(J, F, 2 + (L = Q Or R = Q))))

    End While

    G = (i - 1) \ 2 + 1

End Function

Контрольные примеры

Sub Main()

    Dim sb As New StringBuilder
    Dim LF As Char = ControlChars.Lf
    sb.Append("|-| |=|-|=|")
    sb.Append(LF)
    sb.Append("| |-| | |-|")
    sb.Append(LF)
    sb.Append("|=| |-| | |")
    sb.Append(LF)
    sb.Append("| | |-|=|-|")

    Dim pattern As String = sb.ToString

    For w As Integer = 1 To pattern.Split(LF)(0).Length \ 2 + 1
        Console.WriteLine(w.ToString & " : " & G(w, pattern).ToString)

    Next

    Console.ReadKey()

End Sub

Редактировать:

(для тех, кто все еще читает это)

Я попробовал другой подход. Моя идея состояла в том, чтобы отобразить различные ожидаемые модели и действовать соответственно. Сначала нам нужно решить, повернем ли мы влево или вправо, а затем определить количество столбцов, которые будет перемещать наша маленькая обезьяна Амидар (если нужно, поменять местами строку).

Представляя полное решение сначала:

Function GhostLeg(ByVal i As Integer, ByVal p As String) As Integer

    i = i * 2 - 2

    Dim LeftOrRight As New Dictionary(Of String, Integer)
    LeftOrRight(" | ") = 0
    LeftOrRight("-| ") = -1
    LeftOrRight("=| ") = -1
    LeftOrRight("=|-") = -1
    LeftOrRight(" |-") = 1
    LeftOrRight(" |=") = 1
    LeftOrRight("-|=") = 1

    Dim ColumnAdd As New Dictionary(Of String, Integer)
    ColumnAdd("| | | ") = 0
    ColumnAdd("| | |-") = 0
    ColumnAdd("| |-| ") = 0
    ColumnAdd("| | |=") = 0
    ColumnAdd("| |=| ") = 0
    ColumnAdd("| |-|=") = 0
    ColumnAdd("| |=|-") = 0

    ColumnAdd("|=| | ") = 0
    ColumnAdd("|=| |-") = 0
    ColumnAdd("|=| |=") = 0
    ColumnAdd("|-| |-") = 1
    ColumnAdd("|-| | ") = 1
    ColumnAdd("|-| |=") = 1
    ColumnAdd("|-|=|-") = 2
    ColumnAdd("|-|=| ") = 2
    ColumnAdd("|=|-| ") = 2
    ColumnAdd("|=|-|=") = 3

    Const TRIPLESPACE As String = " | | "
    Dim direction As Integer

    For Each line As String In p.Split(Chr(10))
        line = TRIPLESPACE & line & TRIPLESPACE

        direction = LeftOrRight(line.Substring(i + 4, 3))
        If direction = 1 Then
            line = line.Substring(i + 5, 6)
            i += 2 * direction * ColumnAdd(line)

        ElseIf direction = -1 Then
            line = StrReverse(line.Substring(i, 6))
            i += 2 * direction * ColumnAdd(line)

        End If

    Next

    Return 1 + i \ 2

End Function

Удаляя символьно дорогой словарь, а также ненужный |и после еще нескольких "минификаций" мы получаем:

Function G(i,p)
D="- 0= 0=-0 -2 =2-=2"
A="- -1-  1- =1-=-2-= 2=- 2=-=3"
For Each l In p.Replace("|","").Split(Chr(10))
l="   "& l &"   "
w=InStr(D,Mid(l,i+2,2))
If w Then
w=Val(D(w+1))-1
s=InStr(A,If(w=1,Mid(l,i+3,3),StrReverse(Mid(l,i,3))))
i+=If(s,w*Val(A(s+2)),0)
End If
Next
G=i
End Function

По сравнению с моими предыдущими усилиями (282 символа, 308 байтов) выигрыш невелик, но, возможно, этот подход окажется полезным для других, использующих другой язык программирования.

Источник
Другие вопросы по тегам