Bem-vindo ao meu primeiro desafio de código-golfe! :) Vamos pular direto para ele.

Desafio:

Dados dois vetores de ponto flutuante, O (origem) e T (destino), é necessário criar um programa para imprimir os valores L e R em STDOUT.

1. O é um canto da praça
2. T é um canto do quadrado localizado em frente a O
3. L é o ponto 2D (canto) que marca o outro ponto do quadrado incompleto
4. R é o ponto 2D (canto) oposto a L

Regras

5. Os valores para O e T devem ser lidos no STDIN (consulte as entradas de exemplo).
6. Novamente, os valores de L e R devem ser impressos em STDOUT.

Pontuação e bônus

7. Conte os bytes do seu programa.
8. Se o seu programa desenhar linhas que se conectam entre O e L e T e R , subtraia 15 bytes da contagem de bytes.

Exemplos

A primeira linha abrange as entradas (os primeiros colchetes para O e os próximos colchetes para T ) e a outra linha representa a saída esperada.

• [0, 0] [3, 3] Esperado: [0, 3] [3, 0]
• [0, 0] [-2, -2] Esperado: [-2, 0] [0, -2]
• [1, -1] [4, 2] Esperado: [1, 2] [4, -1]
• [0, -1] [0, 1] Esperado: [-1, 0] [1, 0]

AVISO : as entradas e saídas podem ser pontos flutuantes!

Informação importante!

• Os valores O e T podem ser obtidos em qualquer formato, desde que sejam provenientes de STDIN (por exemplo, Inside [] ou () ...), use o formato que você desejar.
• L e R podem ser impressos em qualquer ordem.
• Lembre-se: quando (O-> L-> T-> R-> O) estão conectados, cada lado deve ter o mesmo comprimento!

Ganhando

• Este é o código-golfe, pois o menor número de bytes possível é a resposta!
• A resposta do vencedor será aceita no domingo 15.11.2015 20: 00-22: 00 (horário da Finlândia) (se não estiver errado, essa data será escrita como 15 de outubro de 2015 nos EUA, não se confunda).

Feliz golfe!

Seriamente , 11 bytes

Uma porta da minha resposta TI-BASIC. Calcula mean(X)+i*(X-mean(X)).

,;Σ½;)±+ï*+

Explicação:

,           Read input
;           Duplicate
Σ½          Half the sum (the mean) of the top copy
;           Copy the mean
)           Rotate stack to the left
            Now there's a copy of the mean on the bottom
±+          Negate mean and add to input list
ï*          Multiply by i
+           Add to mean

Entrada como uma lista de dois números complexos: [1-1j,4+2j]e saída no mesmo formato: [(4-1j), (1+2j)].

Sério , 25 bytes

,i││-++½)+-+½)++-½)±+++½)

Toma entrada como uma lista: [x1,y1,x2,y2]

A mesma estratégia da minha resposta em Python, mas em sério!

Explicação:

,      get input
i      flatten list
││     duplicate stack twice, so that we have 4 copies of the input total
-++½)  calculate the first x-value using the formula (x1-y1+x2+y2)/2, and shove it to the end of the stack
+-+½)  calculate the first y-value using (x1+y1-x2+y2)/2, and shove it to the end of the stack
++-½)  calculate the second x-value using (x1+y2+x2-y2)/2, and shove it to the end of the stack
±+++½) calculate the second y-value using (-x1+y1+x2+y2)/2, and shove it to the end of the stack

Experimente online

TI-BASIC, 16 bytes

Para uma calculadora da série TI-83 + ou 84+.

Input X
i∟X+.5sum(∟X-i∟X

A menos que eu tenha entendido mal, a OP disse que eles estavam bem em aceitar entrada e saída como números complexos. A iaqui é a unidade imaginária, não a variável estatística.

O TI-BASIC tem uma mean(função, mas irritantemente não funciona com listas complexas, lançando um ERR:DATA TYPE.

Insira o formulário {1-i,4+2i}para [[1,-1],[4,2]]. A saída está no formato {4-i 1+2i}para [[1,2][4,-1]].

Matlab, 51 45 46 45 42 bytes

Agora a entrada é esperada em um vetor de coluna: [x0;y0;x1;y1](saída no mesmo formato) Eu apenas a modifiquei para ser um programa completo.

z=eye(4);disp((.5-z([2:4,1],:))*input(''))

Ou alternativamente

z=[1,1;-1,1];disp([z',z;z,z']*input('')/2)

Solução antiga:

A entrada espera vetores de coluna, por exemplo f([0;0],[3;3])

@(a,b)[0,1;-1,0]*(b-a)*[.5,-.5]+(b+a)*[.5,.5]

Ele também retorna dois vetores de coluna (como uma matriz 2x2).

Japonês, 29 28 bytes

Japt é uma versão abreviada do Ja vaScri pt . Intérprete

1o5 mZ=>$eval$(Uq'+)/2-UgZ%4

Observe que as funções de seta exigem um navegador compatível com ES6, como as versões mais recentes do Firefox. A entrada entra como uma matriz de 4 itens, por exemplo [1,-1,4,2].

Como funciona

         // Implicit: U = input array
1o5      // Create a range of integers from 1 to 5. Returns [1,2,3,4]
mZ=>     // Map each item Z in this range to:
$eval$(  //  evaluate:
 Uq'+    //   U joined with "+" (equivalent to summing U)
)/2      //  divided by 2,
-UgZ%4   //  minus the item at Z%4 in the input. This translates to [y₁,x₂,y₂,x₁],
         //  which in turn tranlsates to:
         //   [(x₁-y₁+x₂+y₂)/2, (x₁+y₁-x₂+y₂)/2, (x₁+y₁+x₂-y₂)/2, (-x₁+y₁+x₂+y₂)/2]
         //  which is [Lx,Ly,Rx,Ry], or [Rx,Ry,Lx,Ly], depending on the situation.
         // Implicit: Output last expression

Como foi jogado

Primeiro tentei simplesmente copiar a abordagem Python do @ Mego. Isso me deixou com esse monstro de 48 bytes:
(Nota: a entrada atualmente não deve ser agrupada em uma matriz).

[U-V+W+X /2,(U+V-W+X /2,(U+V+W-X /2,(V+W+X-U /2]

Como cada um desses itens precisa ser dividido por 2, é mais curto mapear toda a matriz com mY=>Y/2:

[U-V+W+X,U+V-W+X,U+V+W-X,V+W+X-U]mY=>Y/2

O que agora? Bem, a matriz agora está simplesmente adicionando três das entradas e subtraindo a quarta, seguindo o padrão 1,2,3,0. Assim, poderíamos agrupar as entradas em uma matriz, depois adicioná-las, dividir por 2 e subtrair o item necessário:

[1,2,3,0]mZ=>(Ug0 +Ug1 +Ug2 +Ug3)/2-UgZ

Bom, salvou um byte! Mas é possível reduzir a matriz no início? Vamos tentar empacotá-lo em uma string e dividi-lo novamente em uma matriz com a:

"1230"a mZ=>(Ug0 +Ug1 +Ug2 +Ug3)/2-UgZ

Olhe para isso, outro byte salvo. Mas existe uma maneira ainda melhor? Bem, podemos usar o fato de que [1,2,3,0] ≡ [1,2,3,4] mod 4:

1o5 mZ=>(Ug0 +Ug1 +Ug2 +Ug3)/2-UgZ%4

Mais dois bytes! Agora vamos a algum lugar. Mas isso Ug0 +Ug1 +Ug2 +Ug3está sobrecarregando muito espaço. E se reduzirmos a matriz com adição?

1o5 mZ=>Ur(X,Y =>X+Y /2-UgZ%4

Uau, isso realmente ajudou! Agora estamos com 29 bytes. E, graças a @ ɟ nɟuɐɯɹɐ ɯ o I, eu consegui tirar outro byte da redução. Mas se pudéssemos usar um built-in para somar a matriz, seria muito menor:

1o5 mZ=>Uu /2-UgZ%4

19 bytes! Surpreendente! Infelizmente, o Japt ainda não possui nenhum desses embutidos. Vou adicionar isso quando tiver uma chance. Sugestões são bem-vindas, tanto para o programa quanto para o idioma!

Bem, a partir da v1.4.4, implementei muito mais recursos no Japt do que havia planejado originalmente. Começando com o plano original para a versão mais curta:

1o5 mZ=>Uu /2-UgZ%4

Primeiro, precisamos mudar algumas coisas: as funções são definidas com {e a função soma é x. Esta versão funciona como está:

1o5 mZ{Ux /2-UgZ%4

Agora, @é uma abreviação de XYZ{, permitindo salvar um byte alternando de Zpara X. Além disso, £é um atalho para m@salvar outro byte:

1o5 £Ux /2-UgX%4

Recentemente, implementei um recurso em que um Uno início do programa geralmente pode ser deixado de fora. Devido a um erro de implementação, no entanto, isso também funciona com funções:

1o5 £x /2-UgX%4

Por fim, a gfunção agora envolve se o índice já passou do final da sequência, permitindo remover o %4total de 13 bytes :

1o5 £x /2-UgX

E eu achei 19 incríveis ;-) Teste on-line!

Javascript (Node.js / ES6), 154 bytes

process.stdin.on('data',s=>(s=s.toString().split(','),a=s[0]-0,b=s[1]-0,x=s[2]-0,y=s[3]-0,console.log([a+(c=(a+x)/2-a)+(d=(b+y)/2-b),b+d-c,a+c-d,b+d+c])))

Obter stdin é a parte mais longa do código. A entrada deve ser os pontos separados por vírgula:

echo "0,0,3,3" | node square.js

ngn APL, 21 bytes

⎕←F.5 0J.5×(F←+/,-/)⎕

Isso recebe a entrada como um par de números complexos (por exemplo, 1J¯1 4J2) e imprime a saída da mesma maneira (por exemplo, 4J¯1 1J2). Experimente online na demonstração ngn / apl .

Pitão, 12 bytes

.jL.OQ-R.OQQ

Isso recebe a entrada como um par de números complexos (por exemplo, 1-1j, 4+2j) e imprime a saída como uma matriz (por exemplo, [(4-1j), (1+2j)]). Experimente online.

, 29 caracteres / 43 bytes

ô(ѨŃ(1,5)ć⇀ë(ïø`+`⸩/2-ï[$%4]⸩

Try it here (Firefox only).

CJam, 30 bytes

q~_:.+\:.-(W*+_2$.+@@.-].5ff*`

Experimente online

Isso leva a entrada como uma lista de listas, por exemplo, para o último exemplo:

[[0 -1] [0 1]]

Explicação:

q~      Get and interpret input.
_       Make a copy.
:.+     Reduce the list of two points with vector sum operator.
\       Swap copy of input to top.
:.-     Reduce the list of two points with vector difference operator.
(W*+    Turn (x, y) into orthogonal (y, -x) by popping off first element, inverting
        its sign, and concatenating again. We now have center and offset vector.
_2$     Create a copy of both...
.+      ... and add them.
@@      Rotate original values to top...
.-      ... and subtract them.
]       Wrap the two results...
.5ff*   ... and multiply all values by 0.5.
`       Convert list to string.

Prolog, 118 bytes

p([A,B],[C,D]):-read([E,F,G,H]),I is(E+G)/2,J is(F+H)/2,K is(G-E)/2,L is(H-F)/2,A is I-L,B is J+K, C is I+L, D is J-K.

Um pouco mais legível:

p([A,B],[C,D]):-read([E,F,G,H]),
                        I is(E+G)/2,
                        J is(F+H)/2,
                        K is(G-E)/2,
                        L is(H-F)/2,
                        A is I-L,
                        B is J+K, 
                        C is I+L, 
                        D is J-K.

Para iniciar o programa:

p(X,Y).

Exemplo de entrada quando os cantos conhecidos são [1, -1] [4, 2]:
[1, -1,4,2]

Exemplo de saída, onde X e Y conterão os cantos desconhecidos:
X = [1.0, 2.0],
Y = [4.0, -1.0]

Experimente aqui online

Edit: Alterado para ler as entradas de STDIN

Python 3, 102 bytes

g=lambda a,b,c,d:((a-b+c+d)/2,(a+b-c+d)/2,(a+b+c-d)/2,(d+b-a+c)/2)
print(g(*map(float,input().split())))

A entrada é obtida no formulário x1 y1 x2 y2, em uma única linha.

Experimente online

Python 2, 56 bytes

i=input()
s=sum(i)/2.0
print s-i[1],s-i[2],s-i[3],s-i[0]

A entrada pode ser x1,y1,x2,y2ou(x1,y1,x2,y2)