As coordenadas no mundo da Terra plana consistem em latitude (x) e longitude (y), que são números inteiros no intervalo de 0 a 9999. Muito parecido com números inteiros gaussianos , mas eles sempre são escritos usando esta notação:

411S 370E

Ou seja, com Sou Nanexado à latitude e / Eou Wanexado à longitude, com espaço (s) entre os dois componentes.

Objetivo

Escreva um programa (não uma função) que leia duas coordenadas, separadas por espaços em branco, e produza sua soma. A primeira coordenada é um ponto de partida, a segunda é um deslocamento e a saída é a posição resultante.

Entrada / Saída

Como esse desafio é parcialmente sobre formatação, tentarei definir os formatos de entrada e saída sem ambiguidade.

O formato de entrada preferido possui 1 espaço entre os componentes de coordenadas, sem zeros à esquerda e um caractere de nova linha entre as duas coordenadas. O programa deve poder ler o formato preferido.

A saída pode conter qualquer quantidade de espaço em branco e zeros à esquerda. Se for diferente do formato de entrada preferido, o programa também deverá poder ler esse formato.

Apenas para esclarecer, a entrada não pode (não) conterá caracteres de formatação adicionais. Apenas espaços e novas linhas, quando necessário.

Pontuação

Esta é uma experiência sobre uma nova condição vencedora. Escolherei o vencedor aceitando uma resposta em algumas semanas. Se uma resposta melhor aparecer depois, alterarei a resposta aceita.

A pontuação do programa é sua contagem de bytes. O programa vencedor é menor que 400 bytes, possui o menor número de bytes, mas é escrito na linguagem de programação mais detalhada . Para determinar o vencedor:

• Remover programas com contagem de bytes 400 ou mais (eles podem participar, mas não podem vencer)
• Considere apenas o programa mais curto para cada linguagem de programação
• O programa mais longo vence

Os poliglotas competem contra programas em todos os idiomas em que são válidos (por exemplo, se um programa é válido em ambos bashe shele compete com programas em ambos os idiomas).

Casos de teste

Nos casos de teste, as duas primeiras linhas são a entrada e a terceira linha é a saída.

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

(a direção do zero não importa, tanto na entrada quanto na saída)

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

(valores máximos)

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

(a direção do zero não importa na saída)

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

(sem valores negativos; mude a direção se precisar alterar o sinal)

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

(se o programa gerar zeros à esquerda e vários espaços, ele deverá ser capaz de lê-los; também deve poder ler entradas que não os contenham)

8888N 8888W
9999N 9999W

(entrada inválida - qualquer comportamento é aceitável, incluindo falha e loop 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.

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.

Foi realmente desafiador estar com 400 caracteres.

Algumas notas:

• A versão original tinha ADD c TO a.qual é uma das minhas declarações verbais favoritas.
• O editor interno não aceitaria isso como um liner 1
• Usando sub-rotinas com FORMe PERFORMexplodiu a contagem de caracteres, mantive as macros
• As instruções de encadeamento com dois pontos são desencorajadas fora das declarações de dados, mas eram necessárias para salvar bytes
• + sem um espaço anterior é um operador de deslocamento, exigindo muitos espaços no código
• ABAP escreve um espaço após números, daí o truque para substituir apenas o sinal
• Para usar RIGHTPLUSa expressão necessária para ser um número, é necessário multiplicar por 1, mas o formato tem decimais.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

Acho que estou chegando a um limite agora. Consegui remover 51, 60 68 72 74 bytes de uma resposta que achei que estava bem. =)

Foram removidos 8 bytes por inputdentro strsplit, graças a Luis Mendo. Foram removidos outros 6 bytes, levando toda a entrada para uma matriz de células em vez de duas. Foram removidos outros 8 bytes, levando as duas últimas instruções para dentro disp(). Foram removidos 6 bytes removendo chare alguns colchetes. Isso não foi possível em uma revisão anterior da resposta. Dividir os elementos da célula em quatro variáveis ​​custou 15 bytes, mas salvou 24, portanto, 9 bytes salvos! 8 bytes adicionais devido ao dispesquema aprimorado . 5*~~ssalva dois bytes em comparação com (s>0)*5. Assim, 4 novos bytes salvos (para se). Tomar o oposto dessa última expressão economiza mais 2 bytes, 83-5*~sé menor que78+5*~~s

Código de golfe:

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

Mesmo código, mas com quebras de linha:

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 teste:

Salve o acima 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 é bem detalhado, para os padrões de golfe. Vamos ver...

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

Editar para adicionar: Acabei de olhar para as outras respostas e estou surpreso que minha entrada seja uma das mais curtas! Talvez R não seja tão detalhado quanto eu pensava ...

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

Notas

• Salvar como A.java, compilar com javac A.java, executar com java A. Em seguida, insira a linha de entradas separada ou como duas entradas separadas no stdin.

Saídas:

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 uma declaração preparada que usa 2 parâmetros de caracteres. Um parâmetro para cada linha de entrada.

É chamado da seguinte forma

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

e gera uma linha contendo uma coluna de caractere único para o 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;}}}

Uma versão mais legível:

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

Golfe em Java é um tipo especial de diversão. As duas linhas de código a seguir fazem o mesmo, mas a primeira é mais curta:

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

O código lê 4 tokens da entrada padrão. Para cada token, a parte até o último caractere é convertida em int, e o último caractere inverte opcionalmente seu sinal.

Em seguida, adiciona o valor lido duas iterações atrás. Java inicializa matrizes para 0, portanto, nas duas primeiras iterações, isso fará a coisa certa.

Em seguida, ele formatará os valores e os imprimirá. No entanto, nas duas primeiras iterações, ela imprime a sequência vazia (para que duas quebras de linha extras apareçam na saída).

Ele usa alguma aritmética descolada para que a variável de iteração (4,3,2 ou 1) e o sinal (-1 ou 1) possam ser combinados em um índice baseado em zero na string "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

É muito curto, desculpe. Eu fiz o meu melhor.

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]}*' '

Bytes C - 267

Eu acho que C seria longo ... poderia muito bem colocá-lo. ; _;

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

Observe que o intérprete possui uma caixa de entrada de linha única. Colar o formato preferido substitui a nova linha por um espaço. A obtenção de valores inteiros &já consome espaços à esquerda e zeros, para que o formato preferido possa ser lido na pilha &~&~&~&~sozinho. Adicionando etapas para colocar os valores em uma linha em branco para que se possa recuperar e comparar os vetores, uma coordenada por vez, o seguinte programa de 136 bytes (excluindo notas à direita da linha) pode ser usado:

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

A captura: a saída força um espaço adicional após números inteiros, portanto, é impossível produzir no formato preferido . Por exemplo, a saída aparecerá como em 1000 N 9999 Wvez de 1000N 9999W. Para verificar e ignorar espaços antes da direção de cada coordenada na entrada, são necessários quatro loops adicionais (um para cada coordenada). Um único loop é mostrado abaixo:

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

O programa resultante pode ter vários espaços em qualquer lugar da entrada (exceto entre dígitos).

Exemplo de entrada: 0001 N 4545 W 0999 N 5454 W

Lua, 333 328 bytes

Possui sistema de entrada inválida de alto nível e loop infinito absolutamente inovador 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

Desfrutar ;)

Editar: salvou 5 bytes ao renomear math.abscomo me 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;

Não faz nada inteligente, apenas atravessa o 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;

As regras devem ter uma cláusula adicional dizendo que apenas o idioma com pelo menos 2 entradas pode vencer.

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

demolir

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 falando, "moste verbose" provavelmente seria Mathematica ou 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];

• saída é bastante não formatada, nem mesmo uma nova linha de treinamento
• imprime números grandes para obter resultados muito grandes

Agora, como posso dobrar o tamanho disso ...

demolir

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

Explicação

{~)}:"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 os casos de teste. Sempre insere N ou W por 0. Tenho certeza de que um jogador de golfe Python melhor do que eu poderia economizar mais alguns bytes.

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

Golpeei 57 poderosos bytes devido a algumas ótimas dicas do @ mbomb007 e do @Titus plus, identificando o fato de que eu poderia combinar as duas raw_inputs com um espaço e depois usar um .split () que se divide no espaço sem especificá-lo. O algoritmo é o mesmo, mas é muito melhor jogado.

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]