Şu an neredeyim?

dYalnızca harfleri içeren bir dize verildiğinde , NSWEseyahat ettiğim koordinatları (soldan sağa, açgözlülükle tüketen) ve bulunduğum yerdeki son koordinatı belirler.

Soldan sağa koordinatları okumak için kurallar:

• Bir sonraki karakter ise N veyaS :
  • NVeya sonrasındaki karakter Sbaşka bir iseN veyaS :
    • Sadece ilkini tüket N veya S.
    • Çıktı [0,1] içinN
    • Çıktı [0,-1]içinS
  • Eğer sonra karakter Nveya SbirW yaE :
    • Tüketin hem Nveya SveW ya da yaE .
    • Çıktı [1,1]veya [-1,1]içinNEve NWsırasıyla.
    • Çıkış [1,-1]veya [-1,-1]için SEve SWsırasıyla.
• Karakter bir Eveya Wile belirtilmemişse bir SveyaN :
  • EVeya tüketin W.
  • Çıktı [1,0]için E.
  • Çıktı [-1,0]için W.

Çalıştı örnek

NSWE

[0,1]   (North      N)
[-1,-1] (South-west SW)
[1,0]   (East       E)
[0,0]   (N+SW+E = Didn't actually move)

Bunun herhangi bir biçimde olabileceğine dikkat edin, işte geçerli geçerli çıktıların diğer örnekleri:

[[0,1],[-1,-1],[1,0],[0,0]]


[[[0,1],[-1,-1],[1,0]],[0,0]]


"0,1\n0,-1\n-1,0\n1,0\n0,0"

Vb...

Daha fazla örnek

SWSENNESWNE

[-1,-1]
[1,-1]
[0,1]
[1,1]
[-1,-1]
[1,1]
[1,0]

NNEESESSWWNW

[0,1]
[1,1]
[1,0]
[1,-1]
[0,-1]
[-1,-1]
[-1,0]
[-1,1]
[0,0]

NENENEE

[1,1]
[1,1]
[1,1]
[1,0]
[4,3]

nen

[1,1]
[0,1]
[1,2]

EEE

[1,0]
[1,0]
[1,0]
[3,0]

kurallar

• Boşlukları ihlal etmeyen herhangi bir uygun formatta çıktı alabilirsiniz.
• Açgözlülükle tüketmelisin NWE, asla N,W,E, her zamanNW,E .
  • Şunun için geçerlidir: SW*, SE*, NW*,NE* .
  • Açgözlülükle soldan sağa tüketiyorsun.
• Olan kod golf , en düşük bayt sayımı kazanır.

Python 2 , 116 bayt

import re
a=[(int(s,35)%5-3,('N'in s)-('S'in s))for s in re.findall('[NS][EW]?|.',input())]
print a,map(sum,zip(*a))

Çevrimiçi deneyin!

Çıkışı ile [(3+4j), 1, -1j, …], 91 bayt

lambda x:[sum(1j**(ord(c)%8%5)for c in s)for s in[x]+re.findall('[NS][EW]?|.',x)]
import re

Çevrimiçi deneyin!

Bu lambda, Gauss tamsayılarının bir listesini verir : ilki son koordinattır ve diğerleri de oraya ulaşmak için gerekli adımlardır.

Ataşesi , 80 bayt

V#Sum##{Chop[1-ToBase[22260446188,3],2][Sum@Ords=>MatchAll[_,/"[NS][WE]|."]%11]}

Çevrimiçi deneyin!

Bu bir dize argümanını alan anonim bir işlevdir.

açıklama

İlk görev, bu sorunun ayrıştırma aşamasını uygulamaktır. Girdiyi ( _) ayrıştırmak için basit bir Regex kullanmayı en kısa buldum :

MatchAll[_,/"[NS][WE]|."]

Bu, regex'in tüm oluşumlarıyla eşleşir [NS][WE]|. , diğer birçok görüldüğü gibi . Bu istekle istenen talimatı verir.

Şimdi, her yönetime bir karma işlevi uygulayacağız. Her yöne ait kod noktalarını alır ve toplarız. Bu, aşağıdaki eşlemeyi verir:

Direction       Ord-sum
E               69
N               78
S               83
W               87
NE              147
SE              152
NW              165
SW              170

Bu değerleri daha küçük bir alana eşleştirmeye çalışacağız; modülo bunun için faydalıdır ve biz olabilir tüm Sağlanan girişler için benzersiz değerleri sonuçları en küçük modülo göstermek kalanlar tarafından 11. Sıralama'yı olduğunu, bu bize aşağıdaki tabloyu veriyor:

Direction       Ord-sum         % 11
NW              165             0
N               78              1
E               69              3
NE              147             4
SW              170             5
S               83              6
SE              152             9
W               87              10

Şimdi, tarafından kodlanan bir girdi yazışmalarımız var Sum@Ords=>[...]%11. Daha sonra, bu kalıntıları noktalara dönüştürmeliyiz. Başka bir eşleme türetmeye çalışacağız, bu, "seyrek doldurma değerlerini" yönlere uymayan karelere eklemek anlamına gelir:

Direction       Hash        Coordinates
NW              0           [-1, 1]
N               1           [0, 1]
--             (2)          [0, 0]
E               3           [1, 0]
NE              4           [1, 1]
SW              5           [-1, -1]
S               6           [0, -1]
--             (7)          [0, 0]
--             (8)          [0, 0]
SE              9           [1, -1]
W               10          [-1, 0]

Şu anda karma tarafından endekslenebilir bir liste verebilecek bir dizi noktamız var:

[-1, 1] [0, 1] [0, 0] [1, 0] [1, 1] [-1, -1] [0, -1] [0, 0] [0, 0] [1, -1] [-1, 0]

Şimdi, bunu yalnızca -1s, 0s ve 1s'den oluşan biçimini görerek sıkıştıracağız . Liste çiftleri temsil ettiğinden, veriyi kaybetmeden listeyi düzleştirebiliriz. Daha sonra, her bir sayıyı xalıp hesaplarsak 1-x, aşağıdaki listeyi alırız:

2 0 1 0 1 1 0 1 0 0 2 2 1 2 1 1 1 1 0 2 2 1

Bunu bir taban 3 numarasına dönüştürebiliriz:

20101101002212111102213

10 tabanına dönüştürme:

20101101002212111102213 ≡ 2226044618810

Özetlemek gerekirse, puanlarımızı aldık, eşleştirdik, her bir elemanı çıkardık 1ve tabandan dönüştürerek 3bize vererek 22260446188. Bu şekilde açabiliriz:

1. Taban 3'e dönüştür: ToBase[22260446188,3]
2. Birinden çıkartılan her sayıyı al (kendi kendine ters): 1-ToBase[22260446188,3]
3. Listeyi tekrar eşleştirin: Chop[1-ToBase[22260446188,3],2]

Bu bize orijinal çiftlerimizi verir. Daha sonra, yukarıda belirtilen endekslemeyi şöyle yapabiliriz:

(chopped value)[hashes]

Çünkü, Attache'de bir diziye göre indeksleme, bu indekslere karşılık gelen tüm elemanları döndürür. (Yani [1,2,3,4][ [0,0,-1,1] ] = [1,1,4,2],.) Şimdi, OP'nin yürüdüğü yolun yönlerine sahibiz. Geride kalan toplamı hesaplamak.

Böylece bu sonucu bir lambda {...}ile yakalarız ve a##bikincisi olmak üzere bir işlev bileşimindeki ( ) ilk işlev olarak koyarız V#Sum. Bu, girdi verildiğinde xgenişleyen bir çatal :

V[x, Sum[x]]

SumBir 2B dizi verildiğinde, dizideki her sütunu toplar (vectorized toplamının bir sonucu olarak). Yani, bu yönleri nihai varış noktasıyla eşleştirir ve nihai sonucumuzu elde ederiz.

JavaScript (ES6), 102 bayt

Bir dize döndürür.

s=>s.replace(/[NS][EW]|./g,s=>(D=d=>!!s.match(d),x+=h=D`E`-D`W`,y+=v=D`N`-D`S`,[h,v]+`
`),x=y=0)+[x,y]

Çevrimiçi deneyin!

MATL , 45 bayt

'NS' 'WE'Z*Z{2MhX{h'eklihfmj'X{YX9\3_2&YAqts

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

Açıklama (örneğin)

'NSWE'Bir örnek olarak girişi düşünün .

'NS' 'WE'  % Push these two strings
           % STACK: 'NS', 'WE'
Z*         % Cartesian product. Gives a 4×2 char matrix
           % STACK: ['NW'; 'NE'; 'SW'; 'SE']
Z{         % Cell array of rows (strings)
           % STACK: {'NW', 'NE', 'SW', 'SE'}
2M         % Push again the inputs of the second-last function call
           % STACK: {'NW', 'NE', 'SW', 'SE'}, 'NS', 'WE'
h          % Concatenate horizontally
           % STACK: {'NW', 'NE', 'SW', 'SE'}, 'NSWE'
X{         % Cell array of individual elements (chars)
           % STACK: {'NW', 'NE', 'SW', 'SE'}, {'N', 'S', 'W', 'E'}
h          % Concatenate horizontally
           % STACK: {'NW', 'NE', 'SW', 'SE', 'N', 'S', 'W', 'E'}
'eklihfmj' % Push this string
           % STACK: {'NW', 'NE', 'SW', 'SE', 'N', 'S', 'W', 'E'}, 'eklihfmj'
X{         % Cell array of individual elements (chars)
           % STACK: {'NW','NE','SW','SE','N','S','W','E'},{'e','k','l','i','h','f','m','j'}
YX         % Implicit input. Regexp replace: replaces 'NW' by 'e', then 'NE' by 'k', etc.
           % Note that the two-letter combinations are replaced first, which implements
           % the greediness; and the target letters do not appear in the source, which
           % avoids unwanted interactions between replacements
           % STACK: 'hlj'
9\         % Modulo 9 (of codepoints), element-wise
           % STACK: [5, 0, 7]
3_2&YA     % Convert to base 3 with 2 digits. Gives a 2-column matrix
           % STACK: [1, 2; 0, 0; 2, 1]
q          % Subtract 1, element-wise
           % STACK: [0, -1; -1, -1; 1, 0]
tXs        % Duplicate. Sum of each column
           % STACK: [0, -1; -1, -1; 1, 0], [0, 0]
           % Implicit display

Java (JDK 10) , 171 bayt

s->{var r="";int i=0,l=s.length,c,x=0,y=0,Y,X;for(;i<l;X=c>1||i<l&&(c=~-s[i]/6%4)>1&&++i>0?c*2-5:0,r+=X+","+Y+" ",x+=X,y+=Y)Y=(c=~-s[i++]/6%4)<2?1-c*2:0;return r+x+","+y;}

Çevrimiçi deneyin!

açıklamalar

Teşekkürler c=~-s[i]/6%4, aşağıdaki haritalama yapılır:

'N' -> ascii: 78 -> -1 = 77 -> /6 = 12 -> %4 = 0
'S' -> ascii: 83 -> -1 = 83 -> /6 = 13 -> %4 = 1
'W' -> ascii: 87 -> -1 = 86 -> /6 = 14 -> %4 = 2
'E' -> ascii: 69 -> -1 = 68 -> /6 = 11 -> %4 = 3

• NSile kontrol edilir c<2ve +1/ -1kullanılarak eşlenir 1-c*2;
• EWile kontrol edilir c>1ve +1/ -1kullanılarak eşlenir c*2-5.

Kredi

• Kevin Cruijssen sayesinde en az 9 byte tasarruf sağladı .

Retina 0.8.2 , 93 bayt

.+
$&¶$&
\G[NS]?[EW]?
$&¶
G`.
W
J
%O`.
+`EJ|NS

m`^((J)?[EJ]*)((S)?[NS]*)
$#2$*-$.1,$#4$*-$.3

Çevrimiçi deneyin! Açıklama:

.+
$&¶$&

Girişi çoğaltın.

\G[NS]?[EW]?
$&¶

İlk kopyayı yönlere ayırın.

G`.

Yukarıdaki işlem tarafından oluşturulan yabancı boş satırları kaldırın.

W
J

Değişim Wiçine Jo arasındaki sıralar, böylece Eve N. ( EArasında hareket Sve Waynı zamanda çalışacak.)

%O`.

Her satırı sırayla sıralayın.

+`EJ|NS

Karşıt yön çiftlerini silin (bu yalnızca kursun son satırını etkiler).

m`^((J)?[EJ]*)((S)?[NS]*)
$#2$*-$.1,$#4$*-$.3

Gerektiğinde işaretler ekleyerek yatay ve dikey hareketlerin sayısını sayın.

Retina 0.8.2 ve Retina 1 arasındaki farkları bilenler, *bunun yerine kullandığı için Retina 1'de 2 byte tasarruf edebileceğime dikkat çekmek ister $*. Oradayken bölme işlemini basitleştirmeye çalıştım, ancak bayt sayısını daha fazla azaltamıyordum, ancak bununla eşitlenebildim:

L$`$(?<=(.*))|[NS]?[EW]?
$&$1

Java 10, 269 265 243 bayt

s->{var r="";int x=0,y=0,t,X,Y,a;for(;!s.isEmpty();r+=X+"|"+Y+" ",s=s.substring(++t),x+=X,y+=Y){a=s.charAt(t=0);if(s.matches("[SN][WE].*")){X=s.charAt(1)<70?1:-1;Y=1-a%2*2;t++;}else{X=a<70?1:a>86?-1:0;Y=a>69&a<87?1-a%2*2:0;}}return r+x+"|"+y;}

Kesinlikle bu meydan okuma için doğru dil ..

Çevrimiçi deneyin.

Açıklama:

s->{                  // Method with String as both parameter and return-type
  var r="";           //  Result-String, starting empty
  int x=0,            //  Ending `x`-coordinate, starting at 0
      y=0,            //  Ending `y`-coordinate, starting at 0
      t,X,Y,a;        //  Temp-integers
  for(;!s.isEmpty()   //  Loop as long as the input-String is not empty yet
      ;               //    After every iteration:
       r+=X+"|"+Y+" ",//     Append the current steps to the result-String
       s=s.substring(t),
                      //     Remove the first `t` characters from the input-String
       x+=X,y+=Y){   //      Append the ending `x`,`y` coordinates with the steps
    a=s.charAt(0);   //    Set `a` to the first character of the input-String to save bytes
    t=1;             //    Set `t` to 1
    if(s.matches("[SN][WE].*")){
                     //   Else-if the input-String starts with N/S followed by E/W:
      X=s.charAt(1)<70?1:-1;
                     //    Set `X` to 1 if 'E', -1 if 'W'
      Y=1-a%2*2;     //    Set `Y` to 1 if 'N', -1 if 'S'
      t++;}          //    Increase `t` by 1
    else{            //   Else:
      X=a<70?1:a>86?-1:0;
                     //    Set `X` to 1 if 'E', -1 if 'W', 0 if 'N' or 'S'
      Y=a>69&a<87?1-a%2*2:0;}}
                     //    Set `Y` 1 if 'N', -1 if 'S', 0 if 'E' or 'W'
  return r+x+"|"+y;} //  Append the ending coordinates, and return the result-String

Perl 5 -n , 94 bayt

$x=$y=0;%X=qw/E ++ W --/;%Y=qw/N ++ S --/;s%(N|S)?(E|W)?%"say $X{$2}\$x.','.$Y{$1}\$y"if$&%gee

Çevrimiçi deneyin!

JavaScript (ES6), 102 bayt

f=
s=>s.replace(/((N)|(S))?((E)|(W))?/g,(m,v,n,s,h,e,w)=>(x+=h=!w-!e,y+=v=!s-!n,m?[h,v]+`
`:[x,y]),x=y=0)

<input oninput=o.textContent=/[^NSEW]/.test(this.value)?``:f(this.value)><pre id=o>0,0

Bir dize döndürür.

Ruby , 75 71 bayt

->x{[*x.scan(/[NS][EW]?|./),x].map{|s|s.chars.sum{|c|1i**(c.ord%8%5)}}}

Çevrimiçi deneyin!

Benj2240 sayesinde -4 bayt.

Karmaşık sayıları döndürmek kabul edilebilir bir çıktı biçimi olarak göründüğü için, sadece çok güzel Lynn'in cevabını gösteren bir liman yapmaktan çok daha golfçü olmayacağını düşünüyorum .

F # (Mono) , 269 bayt

let f s=
 let l,h=(string s).Replace("NW","A").Replace("NE","B").Replace("SW","C").Replace("SE","D")|>Seq.map(function 'N'->0,1|'S'->0,-1|'W'-> -1,0|'E'->1,0|'A'-> -1,1|'B'->1,1|'C'-> -1,-1|'D'->1,-1)|>Seq.mapFold(fun(x,y) (s,t)->(s,t),(x+s,y+t))(0,0)
 Seq.append l [h]

Çevrimiçi deneyin!

sed, 125

Çıkış biçimi ile alarak özgürlüklerin sürümü:

Skor, -rparametrenin sed durumuna getirilmesi için +1'i içerir .

s/(N|S)(E|W)/\L\2,\1 /g
s/N|S/,& /g
s/E|W/&, /g
s/N|E/A/gi
s/S|W/a/gi
p
:
s/(\S*),(\S*) (\S*),(\S*)/\1\3,\2\4/
t
s/Aa|aA//
t

Çevrimiçi deneyin .

Çıkış aşağıdaki gibidir:

• koordinat elemanları virgülle ayrılmıştır
• Her bir koordinat grubu TAB-ayrıklıdır
• son koordinat yeni bir satırda
• tüm sayılar ℤ-unary'dadır:
  • bir Akarakter dizisi + ve tamsayısını gösterir.len(string)
  • bir akarakter dizisi -ve tamsayısını temsil eder-len(string)
  • boş dize temsil eder 0

Örneğin:

• , [0,0]
• ,AA [0,2]
• aaa, [-3,0]

GNU yürütme uzantısı dahil sed 4.2.2 , 147

Mantıklı çıkış biçimi sürümü:

Puan, + 1’i içerir -rparametrenin sed durumuna getirilmesi .

s/(N|S)(E|W)/\L\2 \1\n/g
s/N|S/0 &\n/g
s/E|W/& 0\n/g
s/N|E/1/gi
s/S|W/-1/gi
p
:
s/(\S+) (\S+)\n(\S+) (\S+)/\1+\3 \2+\4/
t
s/\S+/$[&]/g
s/^/echo /e

Çıktı, satır başına bir tane olmak üzere boşlukla ayrılmış koordinatlar olarak verilir. Sonlu ve nihai koordinat kümeleri arasında fazladan bir yeni satır var - sorunlu olup olmadığından emin değilsin.

Çevrimiçi deneyin!

PHP, 153 bayt

Bir regex bölme yapalım; Eşleşmeler arasında dolaşın, ara sonuçları yazdırın ve toplayın:

preg_match_all("/[NS][EW]?|E|W/",$argn,$m);foreach($m[0]as$s){$x+=$p=strtr($s[-1],NEWS,1201)-1;$y+=$q=strtr($s[0],NEWS,2110)-1;echo"$p,$q
";}echo"$x,$y";

Pipe ile çalıştırın -nRveya çevrimiçi deneyin .

C (gcc) , 173 bayt

Bunu regex desteği olmayan bir dilde yapmak ilginç!

f(char*s){char*t="[%d,%d]\n";int x[4]={0},i;for(;*s;*x=x[1]=!printf(t,x[1],*x))for(i=-1;i<5;)if(*s=="S NW E"[++i]){x[i/3+2]+=x[i/3]=i%3-1;i+=2-i%3;s++;}printf(t,x[3],x[2]);}

Çevrimiçi deneyin!