Koordinaten in der Welt der flachen Erde bestehen aus Breitengrad (x) und Längengrad (y), die ganze Zahlen im Bereich von 0 bis 9999 sind. Ähnlich wie Gaußsche Ganzzahlen , aber sie werden immer mit dieser Notation geschrieben:

411S 370E

Das heißt, mit Soder Nan den Breitengrad angehängt und Eoder Wan den Längengrad angehängt, mit Zwischenräumen zwischen den beiden Komponenten.

Tor

Schreiben Sie ein Programm (keine Funktion), das zwei durch Leerzeichen getrennte Koordinaten liest und deren Summe ausgibt. Die erste Koordinate ist ein Startpunkt, die zweite ist eine Verschiebung und die Ausgabe ist die resultierende Position.

Input-Output

Da es bei dieser Herausforderung teilweise um die Formatierung geht, werde ich versuchen, die Eingabe- und Ausgabeformate eindeutig zu definieren.

Das bevorzugte Eingabeformat hat 1 Leerzeichen zwischen den Koordinatenkomponenten, keine führenden Nullen und ein Zeilenumbruchzeichen zwischen den beiden Koordinaten. Das Programm muss das bevorzugte Format lesen können.

Die Ausgabe kann beliebig viele Leerzeichen und führende Nullen enthalten. Wenn es sich vom bevorzugten Eingabeformat unterscheidet, muss das Programm auch dieses Format lesen können.

Um dies zu verdeutlichen, darf (wird) die Eingabe keine zusätzlichen Formatierungszeichen enthalten. Nur Leerzeichen und Zeilenumbrüche, wo nötig.

Wertung

Dies ist ein Experiment zu einer neuen Gewinnbedingung. Ich werde den Gewinner auswählen, indem ich in ein paar Wochen eine Antwort akzeptiere. Wenn danach eine bessere Antwort erscheint, ändere ich die akzeptierte Antwort.

Die Punktzahl für das Programm ist die Anzahl der Bytes. Das Gewinnerprogramm ist kürzer als 400 Byte, hat die geringste Byteanzahl, ist jedoch in der ausführlichsten Programmiersprache geschrieben. So ermitteln Sie den Gewinner:

• Entfernen Sie Programme mit einer Byteanzahl von 400 oder mehr (sie können teilnehmen, aber nicht gewinnen).
• Betrachten Sie nur das kürzeste Programm für jede Programmiersprache
• Das längste Programm gewinnt

Polyglots konkurrieren mit Programmen in allen Sprachen, in denen sie gültig sind (z. B. wenn ein Programm in beiden Sprachen gültig ist bashund shmit Programmen in beiden Sprachen konkurriert).

Testfälle

In den Testfällen sind die ersten beiden Zeilen die Eingabe und die dritte Zeile die Ausgabe.

0S 0E
0S 0W
0N 0E

(Die Richtung von Null spielt sowohl bei der Eingabe als auch bei der Ausgabe keine Rolle.)

0S 9999E
9999N 9999W
9999N 0E

(Maximalwerte)

42S 314W
42N 2718W
0N 3032W

(Die Richtung von Null spielt in der Ausgabe keine Rolle.)

5555N 8888W
7777S 0E
2222S 8888W

(keine negativen Werte; ändern Sie die Richtung, wenn Sie das Vorzeichen ändern müssen)

0001N        4545W
0999N        5454W
1000N        9999W

(Wenn das Programm führende Nullen und mehrere Leerzeichen ausgibt, muss es diese lesen können; es muss auch Eingaben lesen können, die sie nicht enthalten.)

8888N 8888W
9999N 9999W

(ungültige Eingabe - jedes Verhalten ist akzeptabel, einschließlich Absturz und Endlosschleife)

ABAP, 377 365 Bytes

REPORT r.PARAMETERS: x TYPE string,y TYPE string.DEFINE m.SHIFT &1 RIGHT CIRCULAR.TRANSLATE &1 USING 'W-E+S-N+'. END-OF-DEFINITION. DEFINE o.&1 = |{ &1 * 1 SIGN = RIGHTPLUS DECIMALS = 0 }|.TRANSLATE &1 using &2. END-OF-DEFINITION.
SPLIT: x AT space INTO DATA(a) DATA(b),y AT ' ' INTO DATA(c) DATA(d). m: a,b,c,d.a = a + c.b = b + d.o: a '-S+N',b '-W+E'.WRITE: a, b.

Ungolfed:

REPORT r.
PARAMETERS: x TYPE string,
            y TYPE string.
DEFINE m.
  SHIFT &1 RIGHT CIRCULAR.
  TRANSLATE &1 USING 'W-E+S-N+'. 
END-OF-DEFINITION. 

DEFINE o.
  &1 = |{ &1 * 1 SIGN = RIGHTPLUS DECIMALS = 0 }|.
  TRANSLATE &1 using &2.
END-OF-DEFINITION.

SPLIT: x AT space INTO DATA(a) DATA(b),y AT ' ' INTO DATA(c) DATA(d). 
m: a,b,c,d.
a = a + c.
b = b + d.
o: a '-S+N',b '-W+E'.
WRITE: a, b.

Es war tatsächlich eine Herausforderung, innerhalb von 400 Zeichen zu sein.

Einige Notizen:

• Die Originalversion hatte ADD c TO a.eine meiner bevorzugten ausführlichen Aussagen.
• Der eingebaute Editor würde dies nicht als 1-Liner akzeptieren
• Durch die Verwendung von Unterprogrammen mit FORMund die PERFORMExplosion der Zeichenanzahl habe ich mich an Makros gehalten
• Das Verketten von Anweisungen mit Doppelpunkten wird außerhalb von Datendeklarationen nicht empfohlen, wurde jedoch zum Speichern von Bytes benötigt
• + ohne vorangestelltes Leerzeichen ist ein Offset-Operator, der viele Leerzeichen im Code benötigt
• ABAP schreibt ein Leerzeichen nach Zahlen, daher der Trick, nur das Zeichen zu ersetzen
• Um RIGHTPLUSden Ausdruck verwenden zu können, musste eine Zahl sein, also muss man mit 1 multiplizieren, aber dann hat das Format DezimalstellenDECIMALS

JavaScript (ES6), 118 Byte

s=>(g=([i,j,k,l,m,n],[o,p])=>(i=(j>p?-i:+i)+(n>p?-j:+j))<0?-i+o:i+p)(a=s.match(/\d+|\w/g),"SN")+' '+g(a.slice(2),"WE")

MATLAB, 327 304 296 290 282 276 267 259 255 253 Bytes

Ich glaube, ich nähere mich jetzt einem Limit. Ich habe es geschafft, 51, 60 68 72 74 Bytes aus einer Antwort zu entfernen , die ich für gut golfen hielt. =)

Entfernt 8 Bytes durch die Einnahme inputinnerhalb der strsplitdank Luis Mendo. Weitere 6 Bytes wurden entfernt, indem alle Eingaben in ein Zellenarray anstatt in zwei übernommen wurden. Weitere 8 Bytes wurden entfernt, indem beide letzten Anweisungen übernommen wurden disp(). 6 Bytes durch Entfernen charund einige Klammern entfernt. Dies war in einer früheren Überarbeitung der Antwort nicht möglich. Das Aufteilen der Zellenelemente in vier Variablen kostete 15 Bytes, sparte aber 24, also 9 Bytes! 8 zusätzliche Bytes aufgrund eines verbesserten dispSchemas. 5*~~sspart zwei Bytes im Vergleich zu (s>0)*5. Somit werden 4 neue Bytes gespeichert (für s und t). Das Gegenteil dieses letzten Ausdrucks zu nehmen, spart noch 2 Bytes und 83-5*~sist kürzer als78+5*~~s

Golfcode:

x=strsplit([input('','s'),' ',input('','s')]);[a,b,c,d]=x{:};f=@str2num;n=@num2str;i=@sign;s=f(a(1:end-1))*i(a(end)-79)+f(c(1:end-1))*i(c(end)-79);t=f(b(1:end-1))*i(b(end)-79)+f(d(1:end-1))*i(d(end)-79);disp([n(abs(s)),83-5*~s,32,n(abs(t)),87-18*~t,''])

Gleicher Code, aber mit Zeilenumbrüchen:

x=strsplit([input('','s'),' ',input('','s')]);
[a,b,c,d]=x{:};
f=@str2num;
n=@num2str;
i=@sign;
s=f(a(1:end-1))*i(a(end)-79)+f(c(1:end-1))*i(c(end)-79);
t=f(b(1:end-1))*i(b(end)-79)+f(d(1:end-1))*i(d(end)-79);
disp([n(abs(s)),78+5*~~s,32,n(abs(t)),69+18*~~t,''])

Testfälle:

Speichern Sie die oben genannten als flat_earth.m

flat_earth
0S 0E
0S 0W
0N 0E

flat_earth
0S 9999E
9999N 9999W
9999N 0E

flat_earth
42S 314W
42N 2718W
0N 3032W

flat_earth
5555N 8888W
7777S 0E
2222S 8888W

flat_earth
0001N        4545W
0999N        5454W
1000N 9999W

R, 196 Bytes

R ist für Golfstandards ziemlich ausführlich. Wir werden sehen...

i=scan(,'');l=nchar(i);S=W=`-`;N=E=c;n=as.double(substr(i,1,l-1));d=substr(i,l,l);for(j in 1:4)n[j]=get(d[j])(n[j]);o=c(n[1]+n[3],n[2]+n[4]);cat(paste0(abs(o), ifelse(o<0,c("S", "W"),c("N","E"))))

Ungolfed:

input = scan(,'')       # Take input from stdin, separating at newlines and spaces
length = nchar(input)   # Get the number of characters in each input
S=W=`-`                 # These two lines create aliases of `-` (the minus function)
N=E=c                   # and c (the concatenate function).
                        # We will later treat the NSEW part of the coordinate
                        # as a call to a function, to ensure that the numbers
                        # are treated with the correct polarity.
numbers = as.double(substr(input, 1, length-1))
                        # Strip the last character off of every coordinate, convert
                        # to integer
directions = substr(input, length, length)
                        # Strip off the numbers and grab the cardinal directions
for(j in 1:4)
    numbers[j] = get(directions[j])(numbers[j])
                        # For our four numbers, treat the cardinal direction as
                        # a function, which is mapped to `-` for south and west, and
                        # `c` for north and east (which is essentially identity)
output = c(numbers[1]+numbers[3], numbers[2]+numbers[4])
                        # Add together the numbers
cat(paste0(abs(output), ifelse(output<0, c("S", "W"), c("N","E"))))
                        # Output the absolute values of the new coordinates, followed
                        # by "S" or "W" if the number is negative and "N" or "E" if 
                        # the number is positive

Bearbeiten, um hinzuzufügen: Ich habe mir nur die anderen Antworten angesehen und bin überrascht, dass mein Eintrag einer der kürzesten ist! Vielleicht ist R nicht so ausführlich wie ich dachte ...

Java, 372 Bytes

import static java.lang.System.*;class A{public static void main(String[]v){String l=" ",s=console().readLine()+l+console().readLine();Integer i=0,n[]=new Integer[4],y;for(;i<4;i++)n[i]=i.parseInt(s.replaceAll("[A-Z] *",l).split(l)[i])*(s.replaceAll("\\d| ","").charAt(i)==(i%2<1?83:87)?1:-1);i=n[0]+n[2];y=n[1]+n[3];out.println((i<0?-i+"N":i+"S")+l+(y<0?-y+"E":y+"W"));}}

Ungolfed

import static java.lang.System.console;
import static java.lang.System.out;

class A {
    public static void main(String[] v) {
        String l = " ", s = console().readLine() + l + console().readLine();
        Integer i = 0, n[] = new Integer[4], y;
        for (; i < 4; i++)
            n[i] = i.parseInt(s.replaceAll("[A-Z] *", l).split(l)[i]) * (s.replaceAll("\\d| ", "").charAt(i) == (i % 2 < 1 ? 83 : 87) ? 1 : -1);
        i = n[0] + n[2];
        y = n[1] + n[3];
        out.println((i < 0 ? -i + "N" : i + "S") + l + (y < 0 ? -y + "E" : y + "W"));
    }
}

Anmerkungen

• Speichern unter A.java, kompilieren mit javac A.java, ausführen mit java A. Geben Sie dann die Eingabezeile getrennt oder als zwei separate Eingänge auf stdin ein.

Ausgänge:

0S 0E
0S 0W
0S 0W

0S 9999E
9999N 9999W
9999N 0W

42S 314W
42N 2718W
0S 3032W

5555N 8888W
7777S 0E
2222S 8888W

0001N        4545W
0999N        5454W
1000N 9999W

8888N 8888W
9999N 9999W
18887N 18887W

SQL (PostGreSQL 9.4), 305 Byte

PREPARE p(char,char)AS
SELECT string_agg(abs(n)||substr('SNNEEW',i+sign(n)::int,1),' ')FROM(SELECT i,sum(to_number(v,'9999')*CASE right(v,1)WHEN'N'THEN 1 WHEN'E'THEN 1 ELSE -1 END)n
FROM(SELECT CASE WHEN v~'[NS]' THEN 2 ELSE 5 END i,v
FROM regexp_split_to_table($1||' '||$2,' ')v)i
GROUP BY i ORDER BY i)g

Implementiert als vorbereitete Anweisung, die 2 Zeichenparameter akzeptiert. Ein Parameter für jede Eingabezeile.

Es heißt wie folgt

execute p('0S 9999E','9999N 9999W');

und gibt eine Zeile aus, die eine einzelne Zeichenspalte für das Ergebnis enthält. 9999N 0E

Java, 308 Bytes

import java.util.*;class x{public static void main(String[]a){Scanner r=new Scanner(System.in);int[]v=new int[2];int l,x,g,i;for(i=5;i-->1;System.out.println(i<3?""+x*g+"ENWS".charAt(i-g):"")){String s=r.next();x=Integer.parseInt(s.substring(0,l=s.length()-1));x=v[i%2]+=x*=s.charAt(l)>80?-1:1;g=x<0?-1:1;}}}

Eine besser lesbare Version:

import java.util.*;
class x
{
    public static void main(String[]args)
    {
        Scanner r = new Scanner(System.in);
        int[] v = new int[2];
        for (int i = 5; i-->1; )
        {
            String s = r.next();
            int l = s.length() - 1;
            int x = Integer.parseInt(s.substring(0, l));
            x = v[i%2] += x *= s.charAt(l) > 'N' ? -1 : 1;
            int g = x < 0 ? -1 : 1;
            System.out.println(i < 3?"" + x * g + "ENWS".charAt(i-g):"");
        }
    }
}

Golfen in Java ist eine besondere Art von Spaß. Die folgenden zwei Codezeilen machen dasselbe, aber die erste ist kürzer:

(x<0?-x:x)
Math.abs(x)

Der Code liest 4 Token von der Standardeingabe. Für jedes Token wird der Teil bis zum letzten Zeichen in konvertiert int, und das letzte Zeichen dreht optional sein Vorzeichen um.

Dann wird der Wert hinzugefügt, der vor 2 Iterationen gelesen wurde. Java initialisiert Arrays auf 0, sodass dies bei den ersten beiden Iterationen das Richtige tut.

Dann werden die Werte formatiert und gedruckt. In den ersten beiden Iterationen wird jedoch stattdessen die leere Zeichenfolge gedruckt (sodass zwei zusätzliche Zeilenumbrüche in der Ausgabe angezeigt werden).

Es wird eine funky Arithmetik verwendet, sodass die Iterationsvariable (4,3,2 oder 1) und das Vorzeichen (-1 oder 1) zu einem auf Null basierenden Index in der Zeichenfolge kombiniert werden können "ENWS".

Perl 6, 130 Bytes

my (\h,\v)=[Z+] lines».split(' ')».map: {m/(.*)(.)/;$1 eq'S'|'W'??-$0!!$0}
say "{abs h}{h <0??'S'!!'N'} {abs v}{v <0??'W'!!'E'}"

Ruby, 186 Bytes

Es ist zu kurz, sorry. Ich habe mein Bestes gegeben.

x=-1
puts gets.scan(/\d+\D/).map{|i|i.to_i*(i[-1]=~/[WS]/?-1:1)}.zip(gets.scan(/\d+\D/).map{|i|i.to_i*(i[-1]=~/[WS]/?-1:1)}).map{|a,b|a+b}.map{|s|s.abs.to_s+%w"NNS EEW"[x+=1][s<=>0]}*' '

C - 267 Bytes

Ich dachte, C wäre lang ... könnte es genauso gut einfach aufstellen. ; _;

#include <stdio.h>
#include <stdlib.h>
int main(){int x,y,z,w;char m,n,o,p;scanf("%d%c %d%c",&x,&m,&y,&n);scanf("%d%c %d%c",&z,&o,&w,&p);int a=x*(m<'O'?1:-1)+z*(o<'O'?1:-1),b=y*(n<'F'?1:-1)+w*(p<'F'?1:-1);printf("%d%c %d%c\n",abs(a),a<0?'S':'N',abs(b),b<0?'W':'E');}

Befunge-93 , 240 Bytes

v
  v$      <
>&>~:" "-!|
vp01p02   <
  v$      <
>&>~:" "-!|
vp03p04   <
  v$      <
>&>~:" "-!|
vp05p06   <
  v$      <
>&>~:" "-!|
 vp07p08  <
v>30g70g40g80g-!
_-:0` v1+
\v\g04_01-*80g
v>10g50g20g60g-!
_-:0` v1+
\v\g02_01-*60g
@>.," ",.,

Beachten Sie, dass der Interpreter über ein einzeiliges Eingabefeld verfügt. Durch Einfügen des bevorzugten Formats wird die neue Zeile durch ein Leerzeichen ersetzt. Das Abrufen von Ganzzahlwerten &verbraucht bereits führende Leerzeichen und Nullen, sodass das bevorzugte Format allein mit dem Stapel gelesen werden kann &~&~&~&~. Durch Hinzufügen von Schritten zum Einfügen der Werte in eine Leerzeile, sodass die Vektoren koordinatenweise abgerufen und verglichen werden können, kann das folgende 136-Byte-Programm (ohne Anmerkungen rechts von der Zeile) verwendet werden:

v                      | blank line to store data
> &10p~20p&30p~40pv    | read and store first vector
 vp08~p07&p06~p05&<    | (backwards) read and store second vector
v>30g70g40g80g-!       | load E/W coordinates
_-:0` v1+              | subtract or add (based on direction)
\v\g04_01-*80g         | change directions if negative
v>10g50g20g60g-!       | load N/S coordinates
_-:0` v1+              | subtract or add (based on direction)
\v\g02_01-*60g         | change directions if negative
@>.," ",.,             | output

Der Catch: Die Ausgabe erzwingt nach Ganzzahlen ein zusätzliches Leerzeichen, sodass eine Ausgabe im bevorzugten Format nicht möglich ist . Beispielsweise wird die Ausgabe als 1000 N 9999 Wstatt angezeigt 1000N 9999W. Um Leerzeichen vor der Richtung jeder Koordinate bei der Eingabe zu überprüfen und zu ignorieren, werden vier zusätzliche Schleifen (eine für jede Koordinate) benötigt. Eine einzelne Schleife ist unten dargestellt:

  v$      <            | throw out " " and repeat
>&>~:" "-!|            | (start read number) get and check character
vp01p02   <            | store

Das resultierende Programm kann an einer beliebigen Stelle in der Eingabe mehrere Leerzeichen enthalten (außer zwischen Ziffern).

Beispiel Eingabe: 0001 N 4545 W 0999 N 5454 W

Lua, 333 328 Bytes

Verfügt über ein ungültiges Eingabesystem auf hoher Ebene und eine absolut innovative Endlosschleife für die wiederholte Verwendung.

m=math.abs p=print::e::c={}for i=1,2 do for s in io.read():gmatch'%S+'do c[#c+1]=s end end for i=1,4 do n=c[i]:sub(1,-2)d=c[i]:sub(-1,-1)c[i]=d==("N"or"E")and n or-n end x=c[2]+c[4]y=c[1]+c[3]a=m(x)b=m(y)if(a or b)>9999 then p'Invalid input\n'goto e end x=x<0 and a.."W"or a.."E"y=y<0 and b.."S"or b.."N"p(y.." "..x.."\n")goto e

Genießen ;)

Bearbeiten: 5 Bytes beim Umbenennen math.absals mund printals gespeichertp

PHP 291 Bytes.

<?php $E=0;$N=0;$l=explode(PHP_EOL,STDIN);foreach($l as $i){ $x=explode(' ',$i); $s=(substr($x[0],-1,1)=='N')?1:-1; $N=$N+((substr($x[0],0,-1)*$s));$s=(substr($x[1],-1,1)=='E')?1:-1;$E=$E+((substr($x[1],0,-1))*$s);}$l=($E<=0)?'W':'E';$u=($N<=0)?'S':'N';echo'<br/>'.abs($N).$u.' '.abs($E).$l;

Macht nichts Kluges, stapft nur durch das Problem.

<?php 
$lines = explode(PHP_EOL, STDIN);
foreach ($lines as $line) {
    $bits = explode(' ', $line);
    $sign = (substr($bits[0],-1, 1) == 'N')? 1 : -1;    
    $N = $N + ( (substr($bits[0],0,-1) * $sign) );
    $sign = (substr($bits[1],-1, 1) == 'E')? 1 : -1;    
    $E = $E + ( (substr($bits[1],0,-1)) * $sign );
}
$side = ($E<=0)?'W':'E';
$up = ($N<=0)?'S':'N';
echo '<br />'.abs($N).$up.' '.abs($E).$side;

Die Regeln sollten eine zusätzliche Klausel enthalten, die besagt, dass nur die Sprache mit mindestens 2 Einträgen gewinnen kann.

PHP, 169 Bytes

Inspiriert von @Paul Drewett:

<?for($i=2;$i--;$e+=$p[1]*(substr($p[1],-1,1)<W?:-1))$n+=($p=explode(' ',trim(fgets(STDIN))))[0]*(substr($p[0],-1)<S?:-1);echo abs($n),'NS'[$n<0],' ',abs($e),'EW'[$e<0];

Nervenzusammenbruch

for($i=2;$i--;                                  // loop twice
    $e+=$p[1]*(substr($p[1],-1,1)<W?:-1)        // add longitude to result
)
    $n+=
        ($p=explode(' ',trim(fgets(STDIN))))    // read line, split at blank
    [0]*(substr($p[0],-1)<S?:-1)                // add latitude to result
    ;
echo abs($n),'NS'[$n<0],' ',abs($e),'EW'[$e<0]; // print result

PHP, 206 197 195 Bytes

wörtlich gesagt, "moste verbose" wäre wahrscheinlich Mathematica oder Mathlab?

<?function i(){preg_match('#\d+(.) (\d+)(.)#',fgets(STDIN),$m);return[$m[0]*($m[1]<S?:-1),$m[2]*($m[3]<W?:-1)];}echo abs($v=($a=i())[0]+($b=i())[0]),'NS'[$v<0],' ',abs($v=$a[1]+$b[1]),'EW'[$v<0];

• Die Ausgabe ist ziemlich unformatiert, nicht einmal eine trainierende Newline
• druckt große Zahlen für zu große Ergebnisse

Wie kann ich die Größe verdoppeln ...

Nervenzusammenbruch

function i()
// read a pair of coordinates from STDIN, return signed values
{
    // read line from STDIN and take (number,character,number,character) from it
    // will produce something like ["111N 222E","N","222","E"]
    preg_match('#\d+(.) (\d+)(.)#',fgets(STDIN),$m);
    return[
        // using a numerical operation on $m[0] casts the string to number (int in this case)
        $m[0]*($m[1]<S?:-1) // convert latitude to signed int: multiply with -1 for $m[1]=='S'
        ,
        $m[2]*($m[3]<W?:-1) // convert longitude to signed int
    ];
}
$a=i();$b=i();  // read coordinates from STDIN
echo            // output:
    abs($v=$a[0]+$b[0])     // 1. unsigned sum of latitudes
    ,'NS'[$v<0]             // 2. direction depending on sign
    ,' ',                   // 3. delimiter
    abs($v=$a[1]+$b[1]),    // 4. unsigned sum of longitudes
    'EW'[$v<0]              // 5. direction depending on sign
;

GolfScript - 111 Bytes

{~)}:"S":"E";{}:"N":"W";"
"/~[{' '/[{.-1<~\-1>`~}/]\}2*]zip[{{+}*}/](.0<{abs'S'}{'N'}if' '+@~.0<{abs'E'}{'W'}if

Erläuterung

{~)}:"S":"E";    # Aliases these as *-1
{}:"N":"W";      # Alieses to nop
"\n"/~           # Splits lines
[{' '/[{.-1<~\-1>`~}/]\}2*]zip    # Parses the input as vectors and applies the aliases
[{{+}*}/]                         # Vector sum
(.0<{abs'S'}{'N'}if' '+@          # Formats output
~.0<{abs'E'}{'W'}if

Python 2.7 - 232 175 Bytes

Funktioniert für alle Testfälle. Fügt immer N oder W für 0 ein. Ich bin sicher, ein besserer Python-Golfer als ich könnte ein paar Bytes mehr rasieren.

f=(raw_input().split(" ")+raw_input().split(" "))
for x in range(4):
 i=f[x]
 if "S" in i or "E" in i:i="-"+i
 f[x]=int(i[:-1])
n=f[0]+f[2]
q=f[1]+f[3]
print str(abs(n))+("S" if n<0 else "N"),str(abs(q))+("E" if q<0 else "W")

BEARBEITEN

Dank einiger großartiger Tipps von @ mbomb007 und @Titus plus, die ich entdeckt habe, dass ich die beiden raw_inputs mit einem Leerzeichen kombinieren könnte, habe ich nur ein .split () verwendet, das sich auf dem Leerzeichen aufteilt, ohne es anzugeben. Der Algorithmus ist der gleiche, aber viel besser Golf gespielt.

f=(raw_input()+" "+raw_input()).split()
for x in 0,1,2,3:
 i=f[x]
 if i[-1]in"SE":i="-"+i
 f[x]=int(i[:-1])
n=f[0]+f[2]
q=f[1]+f[3]
print`abs(n)`+"NS"[n<0],`abs(q)`+"WE"[q<0]