Para normalizar un vector es la escala para una longitud de 1 ( un vector unitario ), manteniendo la dirección consistente.

Por ejemplo, si quisiéramos normalizar un vector con 3 componentes, u , primero encontraríamos su longitud:

| u | = sqrt (u _x ² + u _y ² + u _z ² )

... y luego escala cada componente por este valor para obtener un vector de longitud 1.

û = u ÷ | u |

El reto

Su tarea es escribir un programa o función que, dada una lista no vacía de enteros con signo, lo interprete como un vector y lo normalice. Esto debería funcionar para cualquier cantidad de dimensiones, por ejemplo (casos de prueba redondeados a dos decimales):

[20]           -> [1]
[-5]           -> [-1]
[-3, 0]        -> [-1, 0]
[5.5, 6, -3.5] -> [0.62, 0.68, -0.40]
[3, 4, -5, -6] -> [0.32, 0.43, -0.54, -0.65]
[0, 0, 5, 0]   -> [0, 0, 1, 0]

Reglas:

• Puede suponer que la lista de entrada:
  • Tener al menos un elemento distinto de cero
  • Solo contiene números dentro del rango de coma flotante estándar de su idioma
• Su salida debe tener una precisión de al menos dos decimales . También se permite devolver fracciones / valores simbólicos de "precisión infinita", si así es como su idioma almacena internamente los datos.
• Los envíos deben ser un programa completo que realice E / S o una función. Los envíos de funciones pueden devolver una nueva lista o modificar la lista dada en su lugar.
• Se permiten funciones / clases de vectores incorporados. Además, si su idioma tiene un tipo de vector que admite un número arbitrario de dimensiones, puede tomar una de estas como entrada.

Este es un concurso de código de golf , por lo que debe aspirar a lograr la solución más corta posible (en bytes).

05AB1E , 4 bytes

Código:

nOt/

Pruébalo en línea!

Explicación

n     # Square each element of the input
 O    # Sum all elements
  t   # Take the square root of the sum
   /  # Divide each element by the square root of the sum

JavaScript (ES6), 31 bytes

a=>a.map(n=>n/Math.hypot(...a))

Casos de prueba

let f =

a=>a.map(n=>n/Math.hypot(...a))

console.log(JSON.stringify(f([20]          ))) // -> [1]
console.log(JSON.stringify(f([-5]          ))) // -> [-1]
console.log(JSON.stringify(f([-3, 0]       ))) // -> [-1, 0]
console.log(JSON.stringify(f([5.5, 6, -3.5]))) // -> [0.62, 0.68, -0.40]
console.log(JSON.stringify(f([3, 4, -5, -6]))) // -> [0.32, 0.43, -0.54, -0.65]
console.log(JSON.stringify(f([0, 0, 5, 0]  ))) // -> [0, 0, 1, 0]

Mathematica, 9 bytes

Normalize

Pruébalo en línea!

J , 8 bytes

%+/&.:*:

Pruébalo en línea!

6 bytes %|@j./funcionan si el vector es al menos bidimensional .

Jalea , 5 3 bytes

÷ÆḊ

Pruébalo en línea! o ver el conjunto de pruebas

¡Ahorró 2 bytes gracias a millas!

Octava , 13 bytes

@(x)x/norm(x)

Pruébalo en línea!

C,  73  70 bytes

¡Gracias a @Christoph por guardar un byte!

s,i;f(v,n)float*v;{for(s=0;i++<n;)s+=*v**v++;for(;--i;)*--v/=sqrt(s);}

Pruébalo en línea!

Python, 47 46 bytes

lambda v:[e/sum(e*e for e in v)**.5for e in v]

Pruébalo en línea!

Julia , 9 bytes

normalize

Pruébalo en línea!

CJam , 9 bytes

{_:mhzf/}

Pruébalo en línea!

Explicación

_    e# Duplicate input.
:mh  e# Fold hypothenuse-length over the vector. This gives the norm, unless the vector
     e# has only one component, in which case it just gives that component.
z    e# Abs. For the case of a single negative vector component.
f/   e# Divide each vector component by the norm.

TI-Basic, 6 bytes

Ans/√(sum(Ans2

Ejecutar con {1,2,3}:prgmNAME, donde {1,2,3}es el vector a normalizar.

Divide cada elemento en el vector por la raíz cuadrada de la suma de los cuadrados de sus elementos.

R , 23 bytes

function(v)v/(v%*%v)^.5

Pruébalo en línea!

v%*%vcalcula el producto punto de v consigo mismo.
La función emitirá una advertencia para vectores de longitud 2 o mayores.

Java (OpenJDK 8) , 57 bytes

v->v.stream().map(x->x/v.stream().reduce(0d,Math::hypot))

Pruébalo en línea!

MATL , 5 bytes

t2&|/

Pruébalo en línea!

No estoy completamente seguro de que esta sea la forma más corta de hacerlo. Primero, duplicamos la entrada, luego seleccionamos el segundo tipo de salida de |(que es abs, normo determinant). Finalmente, dividimos la entrada por la norma.

Alternativa para 7 bytes:

t2^sX^/

Haskell , 29 bytes

f x=map(/sqrt(sum$(^2)<$>x))x

Pruébalo en línea!

O para 1 byte más sin puntos: map=<<flip(/).sqrt.sum.map(^2)

Funky , 42 bytes

a=>(d=a::map)(c=>c/d(b=>b^2)::reduce@+^.5)

Pruébalo en línea!

Ohm v2 , 5 bytes

D²Σ¬/

Pruébalo en línea!

C ++ (gcc), 70 bytes

Entrada por std::valarray<float>. Sobrescribe el vector original.

#import<valarray>
int f(std::valarray<float>&a){a/=sqrt((a*a).sum());}

Pruébalo en línea!

Lisp común, 69 bytes

(lambda(v)(mapcar(lambda(x)(/ x(sqrt(loop as y in v sum(* y y)))))v))

Pruébalo en línea!

APL (Dyalog) , 13 12 10 bytes

1 byte guardado gracias a @ Adám

2 bytes guardados gracias a @ngn

⊢÷.5*⍨+.×⍨

Pruébalo en línea!

¿Cómo?

⊢  ÷  .5*⍨  +.  ×⍨
u  ÷    √   Σ   u²

Casco , 8 7 bytes

´(Ṁ/√ṁ□

Pruébalo en línea!

C # (.NET Core) , 51 + 64 = 115 bytes

v=>v.Select(d=>d/Math.Sqrt(v.Select(x=>x*x).Sum()))

Pruébalo en línea!

+64 bytes para el using System;using System.Collections.Generic;using System.Linq;

C # (.NET Core) , 94 + 13 = 107 bytes

v=>{var m=0d;foreach(var x in v)m+=x*x;for(int i=0;i<v.Length;)v[i++]/=Math.Sqrt(m);return v;}

Pruébalo en línea!

+13 bytes para using System;

El enfoque no Linq

DeGolfed

v=>{
    var m=0d;
    foreach (var x in v)
        m+=x*x;

    for (int i=0; i < v.Length;)
        v[i++] /= Math.Sqrt(m);

    return v;
}

Perl 5 , 45 + 1 ( -a) = 46 bytes

say$_/sqrt eval join'+',map"($_)**2",@F for@F

Pruébalo en línea!

Pip , 10 bytes

9 bytes de código, +1 para -pbandera.

g/RT$+g*g

Toma el vector como argumentos separados de la línea de comandos. Pruébalo en línea!

Cómo funciona

      g*g  Arglist, multiplied by itself itemwise
    $+     Sum
  RT       Square root
g/         Divide arglist itemwise by that scalar
           Result is autoprinted (-p flag to format as list)

Pyth, 5 bytes

cR.aQ

Pruébelo en línea: Test Suite

Explicación:

cR.aQQ   implicit Q at the end
c        divide
 R   Q   each element of the input
  .aQ    by the L2 norm of the input vector

Perl 6 , 25 bytes

{$_ »/»sqrt sum $_»²}

Pruébalo en línea!

$_, el argumento de lista para la función, se divide elementwise ( »/») por la raíz cuadrada de la suma de los cuadrados de los elementos ( »²).

Ruby, 39 35 bytes

->v{v.map{|x|x/v.sum{|x|x*x}**0.5}}

-4 bytes gracias a G B.

APL NARS 12 Personajes

f←{⍵÷√+/⍵*2}

Hojas de cálculo de Google, 65 bytes

=ArrayFormula(TextJoin(",",1,If(A:A="","",A:A/Sqrt(Sumsq(A:A)))))

La lista de entrada está en una columna Acon una entrada por celda. Así es como las hojas de cálculo normalmente usarían listas. Desafortunadamente, esto normalmente daría como resultado una larga lista ,0,0,0,0,0,....al final, por lo que debemos ignorar a aquellos con la If Blank then Blank else Mathlógica.

Si todo estuviera en una celda, la solución sería 95 bytes:

=ArrayFormula(TextJoin(",",1,If(Split(A1,",")="","",Split(A1,",")/Sqrt(Sumsq(Split(A1,","))))))

Swift 4, 44 bytes

{a in a.map{$0/sqrt(a.reduce(0){$0+$1*$1})}}

Recalcula la norma vectorial para cada componente, ¡pero al menos es conciso!