Las coordenadas en el mundo de la Tierra plana consisten en latitud (x) y longitud (y), que son enteros en el rango de 0 ... 9999. Al igual que los enteros gaussianos , pero siempre se escriben usando esta notación:

411S 370E

Es decir, con So Nanexado a la latitud, Eo Wanexado a la longitud, con espacio (s) entre los dos componentes.

Objetivo

Escriba un programa (no una función) que lea dos coordenadas, separadas por espacios en blanco, y genere su suma. La primera coordenada es un punto de partida, la segunda es un desplazamiento y la salida es la posición resultante.

De entrada y salida

Dado que este desafío tiene que ver parcialmente con el formato, intentaré definir los formatos de entrada y salida sin ambigüedades.

El formato de entrada preferido tiene 1 espacio entre los componentes de coordenadas, sin ceros a la izquierda y un carácter de nueva línea entre las dos coordenadas. El programa debe poder leer el formato preferido.

La salida puede contener cualquier cantidad de espacios en blanco y ceros a la izquierda. Si es diferente del formato de entrada preferido, el programa también debe poder leer este formato.

Solo para que quede claro, la entrada no puede (no contendrá) ningún carácter de formato adicional. Solo espacios y líneas nuevas donde sea necesario.

Puntuación

Este es un experimento en una nueva condición ganadora. Elegiré al ganador aceptando una respuesta en unas pocas semanas. Si después aparece una mejor respuesta, cambiaré la respuesta aceptada.

La puntuación para el programa es su recuento de bytes. El programa ganador es uno que tiene menos de 400 bytes, tiene la menor cantidad de bytes, pero está escrito en el lenguaje de programación más detallado . Para determinar el ganador:

• Eliminar programas con un conteo de bytes 400 o más (pueden participar pero no pueden ganar)
• Considere solo el programa más corto para cada lenguaje de programación
• El programa más largo gana

Los políglotas compiten contra programas en todos los idiomas en los que son válidos (por ejemplo, si un programa es válido en ambos bashy shcompite contra programas en ambos idiomas).

Casos de prueba

En los casos de prueba, las dos primeras líneas son la entrada y la tercera línea es la salida.

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

(la dirección de cero no importa, tanto en entrada como en salida)

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

(valores máximos)

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

(la dirección de cero no importa en la salida)

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

(sin valores negativos; cambie la dirección si necesita cambiar el signo)

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

(si el programa genera ceros iniciales y varios espacios, debe poder leerlos; también debe poder leer la entrada que no los contiene)

8888N 8888W
9999N 9999W

(entrada no válida: cualquier comportamiento es aceptable, incluido el bloqueo y el bucle infinito)

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.

Sin golf:

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.

En realidad fue un desafío estar dentro de los 400 caracteres.

Algunas notas:

• La versión original tenía ADD c TO a.cuál es una de mis declaraciones detalladas favoritas.
• El editor incorporado no aceptaría esto como un trazador de líneas 1
• Usando subrutinas con FORMy PERFORMexplotó el recuento de caracteres, así que mantuve las macros
• Se desaconseja encadenar declaraciones con dos puntos fuera de las declaraciones de datos, pero era necesario para guardar bytes
• + sin un espacio anterior es un operador de desplazamiento, que requiere muchos espacios en el código
• ABAP escribe un espacio después de los números, de ahí el truco para reemplazar el signo
• Para poder usar RIGHTPLUSla expresión tenía que ser un número, por lo que la necesidad de multiplicar con 1, pero luego el formato tiene decimales.DECIMALS

JavaScript (ES6), 118 bytes

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

Creo que me estoy acercando a un límite ahora. Me las arreglé para eliminar 51, 60 68 72 74 bytes de una respuesta que pensé que estaba bien. =)

Se eliminaron 8 bytes tomando el inputinterior strsplit, gracias a Luis Mendo. Se eliminaron otros 6 bytes tomando toda la entrada en una matriz de celdas en lugar de dos. Se eliminaron otros 8 bytes al tomar las dos últimas declaraciones dentro disp(). Se eliminaron 6 bytes eliminando chary algunos corchetes. Esto no fue posible en una revisión previa de la respuesta. Dividir los elementos de la celda en cuatro variables costó 15 bytes, pero ahorró 24, ¡por lo tanto, 9 bytes ahorraron! 8 bytes adicionales debido a un dispesquema mejorado . 5*~~sahorra dos bytes en comparación con (s>0)*5. Así 4 nuevos bytes guardados (para syt). Tomar lo contrario de esta última expresión guarda otros 2 bytes, 83-5*~ses más corto que78+5*~~s

Código de golf:

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,''])

Mismo código, pero con saltos de línea:

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,''])

Casos de prueba:

Guarde lo anterior como 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 es bastante detallado, para los estándares de golf. Veamos...

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"))))

Sin golf:

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

Editar para agregar: ¡Acabo de ver las otras respuestas y me sorprende que mi entrada sea una de las más cortas! Quizás R no sea tan detallado como pensaba ...

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"));}}

Sin golf

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"));
    }
}

Notas

• Guardar como A.java, compilar con javac A.java, ejecutar con java A. Luego ingrese la línea de entradas separada o como dos entradas separadas en stdin.

Salidas:

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 bytes

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

Implementado como una declaración preparada que toma 2 parámetros de caracteres. Un parámetro para cada línea de entrada.

Se llama de la siguiente manera

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

y genera una fila que contiene una columna de un solo carácter para el resultado. 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;}}}

Una versión más legible:

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):"");
        }
    }
}

Jugar al golf en Java es un tipo especial de diversión. Las siguientes dos líneas de código hacen lo mismo, pero la primera es más corta:

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

El código lee 4 tokens de la entrada estándar. Para cada ficha, la parte hasta el último carácter se convierte inty el último carácter opcionalmente cambia su signo.

Luego agrega el valor que se leyó hace 2 iteraciones. Java inicializa las matrices a 0, por lo que en las dos primeras iteraciones esto hará lo correcto.

Luego formateará los valores y los imprimirá. Sin embargo, en las dos primeras iteraciones, imprime la cadena vacía en su lugar (por lo que aparecen dos saltos de línea adicionales en la salida).

Utiliza algo de aritmética funky para que la variable de iteración (4,3,2 o 1) y el signo (-1 o 1) se puedan combinar en un índice basado en cero en la cadena "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 muy corto, lo siento. Hice mi mejor esfuerzo.

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

Pensé que C sería largo ... también podría ponerlo. ; _;

#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
@>.," ",.,

Tenga en cuenta que el intérprete tiene un cuadro de entrada de línea única. Pegar el formato preferido reemplaza la nueva línea con un espacio. Obtener valores enteros &ya consume espacios iniciales y ceros, por lo que el formato preferido se puede leer en la pila &~&~&~&~solo. Agregando pasos para poner los valores en una línea en blanco para que uno pueda recuperar y comparar los vectores una coordenada a la vez, se puede usar el siguiente programa de 136 bytes (excluyendo las notas a la derecha de la línea):

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

The Catch: la salida fuerza un espacio adicional después de los enteros, por lo que es imposible generar en el formato preferido . Por ejemplo, la salida aparecerá como en 1000 N 9999 Wlugar de 1000N 9999W. Para verificar e ignorar espacios antes de la dirección de cada coordenada en la entrada, se necesitan cuatro bucles adicionales (uno para cada coordenada). A continuación se muestra un solo bucle:

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

El programa resultante puede tener múltiples espacios en cualquier lugar de la entrada (excepto entre dígitos).

Entrada de ejemplo: 0001 N 4545 W 0999 N 5454 W

Lua, 333 328 bytes

Cuenta con un sistema de entrada inválido de alto nivel y un bucle infinito absolutamente innovador para uso repetido.

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

Disfrutar;)

Editar: guardado 5 bytes de renombrar math.abscomo my printcomop

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;

No hace nada inteligente, simplemente avanza el problema.

<?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;

Las reglas deben tener una cláusula adicional que indique que solo el idioma con al menos 2 entradas puede ganar.

PHP, 169 bytes

Inspirado por @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];

Descompostura

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

literalmente hablando, "moste verbose" probablemente sería Mathematica o 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];

• la salida está bastante sin formato, ni siquiera una nueva línea de entrenamiento
• imprime grandes números para resultados demasiado grandes

Ahora, ¿cómo puedo duplicar el tamaño de esto ...

Descompostura

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

Explicación

{~)}:"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

Funciona para todos los casos de prueba. Siempre inserta N o W para 0. Estoy seguro de que un mejor jugador de Python que yo podría eliminar unos pocos bytes más.

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")

EDITAR

Aproveché unos poderosos 57 bytes debido a algunos excelentes consejos de @ mbomb007 y @Titus plus al detectar el hecho de que podría combinar las dos entradas_de_ raw con un espacio y luego usar un .split () que se divide en el espacio sin especificarlo. El algoritmo es el mismo pero mucho mejor golfizado.

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]