एक वेक्टर को सामान्य करें

Question

एक वेक्टर को सामान्य करने के लिए दिशा को संगत रखते हुए, इसे 1 ( एक इकाई वेक्टर ) की लंबाई तक स्केल करना है ।

उदाहरण के लिए, अगर हम, 3 घटकों के साथ एक सदिश को सामान्य करना चाहता था यू , हम पहले इसकी लंबाई मिलेगा:

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

... और फिर इस घटक द्वारा प्रत्येक घटक को एक लंबाई 1 वेक्टर प्राप्त करने के लिए स्केल किया जाता है।

÷ = यू û | यू |

---

चुनौती

आपका कार्य एक प्रोग्राम या फ़ंक्शन लिखना है, जिसने हस्ताक्षरित पूर्णांक की एक गैर-खाली सूची दी है, इसे एक वेक्टर के रूप में व्याख्या करता है, और इसे सामान्य करता है। यह किसी भी संख्या में आयामों के लिए काम करना चाहिए, उदाहरण के लिए (दो दशमलव स्थानों पर परीक्षण के मामले):

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

नियम:

• आप मान सकते हैं कि इनपुट सूची क्या होगी:
  • कम से कम एक गैर-शून्य तत्व हो
  • केवल आपकी भाषा के मानक फ़्लोटिंग पॉइंट रेंज में नंबर होते हैं
• आपका आउटपुट कम से कम दो दशमलव स्थानों पर सटीक होना चाहिए । "अनंत सटीक" अंशों / प्रतीकात्मक मूल्यों को वापस करने की भी अनुमति है, अगर यह आपकी भाषा आंतरिक रूप से डेटा को कैसे संग्रहीत करती है।
• सबमिशन या तो एक पूर्ण कार्यक्रम होना चाहिए जो I / O, या फ़ंक्शन करता है। फ़ंक्शन सबमिशन या तो एक नई सूची वापस कर सकता है, या दी गई सूची को संशोधित कर सकता है।
• बिलियन वेक्टर फ़ंक्शन / क्लासेस की अनुमति है। इसके अतिरिक्त, यदि आपकी भाषा में एक वेक्टर प्रकार है जो मनमाने ढंग से संख्याओं का समर्थन करता है, तो आप इनमें से किसी एक को इनपुट के रूप में ले सकते हैं।

यह एक कोड-गोल्फ प्रतियोगिता है, इसलिए आपको कम से कम समाधान (बाइट्स में) प्राप्त करने का लक्ष्य रखना चाहिए।

Comments

क्या इसके लिए हर संभव इनपुट के लिए कम से कम दो दशमलव स्थान होना चाहिए (जो किसी भी प्रकार के फ्लोटिंग पॉइंट वैल्यू के लिए संभव नहीं है) या केवल आपके द्वारा प्रदान किए गए उदाहरणों के लिए? Eg Steadybox का जवाब आपके सभी परीक्षण के लिए 2 दशमलव स्थान सटीक प्रदान करता है, लेकिन वह वर्गों के योग के लिए ints का उपयोग करता है जो लगभग सभी इनपुट के लिए विफल रहता है (जैसे [0.1, 0.1])।

— क्रिस्टोफ

... अब हम केवल एक मानक के लिए मैप किए गए मानक फ़ंक्शन के साथ एक

— अंतराल के

यह हर संभव इनपुट @Christoph

— FlipTack

@ फीलटैक लेकिन यह मूल रूप से सभी भाषाओं पर लागू होता है क्योंकि फ्लोटिंग पॉइंट में मंटिसा की तुलना में बड़े एक्सपोर्टर होते हैं जिसका मतलब है कि उनके पास हमेशा कोई दशमलव स्थान रखने के लिए पर्याप्त सटीकता नहीं होती है।

— क्रिस्टोफ

4 के उदाहरण में 6 और 5 में क्रमशः -6 को 1 और -1 के लिए सामान्य क्यों नहीं किया जाता है?

— मस्त

Answer 1

05AB1E , 4 बाइट्स

कोड:

nOt/

इसे ऑनलाइन आज़माएं!

व्याख्या

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

Comments

n0t जो मुझे उम्मीद थी /

— YSC

Answer 2

जावास्क्रिप्ट (ईएस 6), 31 बाइट्स

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

परीक्षण के मामलों

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]

Answer 3

गणितज्ञ, 9 बाइट्स

Normalize

इसे ऑनलाइन आज़माएं!

Comments

या #/Norm@#&उसी बाइट की गिनती के लिए।

— मार्टिन एंडर

Answer 4

जे , 8 बाइट्स

%+/&.:*:

इसे ऑनलाइन आज़माएं!

6 बाइट्स %|@j./काम करता है अगर वेक्टर कम से कम 2-आयामी है ।

Comments

परिमाण प्राप्त करने का तरीका पसंद है।

— कोल

@cole 1 बाइट अधिक लंबी:%1%:@#.*:

— फ्रोवनीफ्रॉग

क्या आप कृपया J में निर्जन के लिए स्पष्टीकरण जोड़ सकते हैं?

— मेकएमके 1

% (विभाजित करके) + / (राशि) और: (अंडर) *: (वर्ग)। + दो बातें कहते हैं। + / बातों की एक सूची है। और।: निम्नलिखित ऑपरेशन को पहले लागू करके पूर्ववर्ती ऑपरेशन को संशोधित करता है और इसके बाद इसका उलटा करता है। % आम तौर पर दो तर्क देता है, लेकिन (% f) x से x% (fx) का एक फ़ंक्शन है। अधिकांश ऑपरेटर स्वचालित रूप से सूचियों पर काम करते हैं।

— बजे रोमन ओडिसी

और समान सिद्धांतों द्वारा, फ़ंक्शन जो "सामान्य करता है" एक वेक्टर को प्रत्येक घटक के लिए ऐसी संख्या जोड़कर जो उन्हें शून्य करने के लिए योग है "- + /% #"।

— रोमन ओडिसी

Answer 5

जेली , 5 3 बाइट्स

÷ÆḊ

इसे ऑनलाइन आज़माएं! , या परीक्षण सूट देखें

मीलों तक 2 बाइट्स बचाए!

Comments

3 बाइट्स÷ÆḊ

— मील

@ मीलों हुह, उस बिल्डिन के बारे में कभी नहीं पता था। धन्यवाद

— caird coinheringaahing

दुर्भाग्य से कि अंतर्निहित TIO + ve मॉड प्रति स्केल के लिए TIO उदाहरण के लिए निरपेक्ष मूल्य .. समस्या का संकेत रखने का अनुरोध किया

— jayprich

Answer 6

ऑक्टेव , 13 बाइट्स

@(x)x/norm(x)

इसे ऑनलाइन आज़माएं!

Answer 7

सी,  73  70 बाइट्स

बाइट बचाने के लिए @Christoph का शुक्रिया!

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

इसे ऑनलाइन आज़माएं!

Comments

+1। s=0,i=0इसके बजाय s=i=0एक बचाता है

— xanoetux

मैं प्यार करता हूँ, s[-i]लेकिन दुख *--v/=sqrt(s);की बात है 1 बाइट छोटी है।

— क्रिस्टोफ

@xanoetux धन्यवाद, लेकिन मुझे फ़ंक्शन के अंदर वैरिएबल को इनिशियलाइज़ करने की आवश्यकता है, क्योंकि फ़ंक्शंस को पुन: उपयोग करने की आवश्यकता है । इसके अलावा, वैश्विक चर के रूप में, sऔर iस्वचालित रूप से 0. के लिए प्रारंभ किया जाता है (मुझे पता iचलता है कि मुझे फ़ंक्शन को प्रारंभ करने की आवश्यकता नहीं है , क्योंकि फ़ंक्शन हमेशा इसे 0 पर छोड़ देता है)

— स्टेडबॉक्स

@ क्रिसटोफ धन्यवाद! मैं शुरू में फ़ंक्शन से मूल्यों को प्रिंट कर रहा था, इसलिए मुझे v[-i]सही क्रम में मान प्राप्त करने की आवश्यकता थी ।

— स्टेडीबॉक्स

Answer 8

पायथन, 47 46 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 9

जूलिया , 9 बाइट्स

normalize

इसे ऑनलाइन आज़माएं!

Answer 10

CJam , 9 बाइट्स

{_:mhzf/}

इसे ऑनलाइन आज़माएं!

व्याख्या

_    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.

Answer 11

टीआई-बेसिक, 6 बाइट्स

Ans/√(sum(Ans2

साथ चलाएं {1,2,3}:prgmNAME, जहां {1,2,3}वेक्टर को सामान्यीकृत किया जाना है।

वेक्टर के प्रत्येक तत्व को उसके तत्वों के वर्ग के योग के वर्गमूल से विभाजित करता है।

Comments

हमें एक ही जवाब मिला!

— kamoroso94

@ kamoroso94 वूप्स! जब मैंने यह पोस्ट किया था तब आपका नहीं देखा था। यदि आप अपने उत्तर से स्पष्टीकरण जोड़ना चाहते हैं तो मैं इसे हटा दूंगा।

— pizzapants184

नाह मैं सिर्फ मेरा निकाल देंगे। आपने अपने उत्तर में अधिक प्रयास किया: पी

— kamoroso94

Answer 12

आर , 23 बाइट्स

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

इसे ऑनलाइन आज़माएं!

v%*%vखुद के साथ v के डॉट उत्पाद की गणना करता है।
फ़ंक्शन लंबाई 2 या अधिक वैक्टर के लिए चेतावनी जारी करेगा।

Answer 13

जावा (ओपनजेडके 8) , 57 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 14

MATL , 5 बाइट्स

t2&|/

इसे ऑनलाइन आज़माएं!

मुझे पूरा यकीन नहीं है कि ऐसा करने का यह सबसे छोटा तरीका है। सबसे पहले, हम इनपुट को डुप्लिकेट करते हैं, फिर दूसरे आउटपुट प्रकार का चयन करें |(जो या तो है abs, normया determinant)। अंत में, हम इनपुट को आदर्श से विभाजित करते हैं।

7 बाइट्स के लिए वैकल्पिक:

t2^sX^/

Answer 15

हास्केल , 29 बाइट्स

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

इसे ऑनलाइन आज़माएं!

या 1 बाइट के लिए अधिक पॉइंटफ्री: map=<<flip(/).sqrt.sum.map(^2)

Answer 16

फंकी , 42 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 17

ओम v2 , 5 बाइट्स

D²Σ¬/

इसे ऑनलाइन आज़माएं!

Answer 18

सी ++ (जीसीसी), 70 बाइट्स

द्वारा इनपुट std::valarray<float>। मूल वेक्टर को ओवरराइट करता है।

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

इसे ऑनलाइन आज़माएं!

Comments

मैं अभी और फिर हर बार कोडगुल्फ को दुबक रहा हूं, लेकिन क्या यह # Cimport नहीं दिया गया है, जो "#import" है, जो एक Microsoft विशिष्ट एक्सटेंशन है?

— १०:०१ पर फॉरेस्टेलिन २es

@phresnel #importकम से कम GCC, Clang और MinGW के साथ भी काम करती है। लेकिन, हाँ, यह मानक सी ++ नहीं है।

— स्टेडीबॉक्स

@phresnel मैं gcc निर्दिष्ट करना भूल गया। फिक्स्ड।

— सु

Answer 19

आम लिस्प, 69 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 20

एपीएल (डायलॉग) , 13 12 10 बाइट्स

1 बाइट ने @ Adám को धन्यवाद दिया

2 बाइट्स @ngn की बदौलत बच गए

⊢÷.5*⍨+.×⍨

इसे ऑनलाइन आज़माएं!

कैसे?

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

Comments

ट्रेन के लिए कम:⊢÷.5*⍨(+/×⍨)

— Adám

@ बहुत बहुत धन्यवाद! मैं घंटों के लिए कोशिश कर रहा है, काम करने के लिए किसी भी ट्रेन नहीं मिल सका

— ऊरीएल

हमें उस बारे में कुछ करना चाहिए, क्योंकि यह वास्तव में इतना कठिन नहीं है। जब आपके पास एक मोनडिक फ़ंक्शन होता है (सबसे दाहिनी ओर के अलावा), इसकी बाईं ओर एक कोष्ठक शुरू करें (या ∘यदि यह व्युत्पन्न नहीं है तो इसका उपयोग करें )। इसके अलावा, बस स्वैप ⍺और के ⍵लिए ⊣और ⊢: {⍵÷.5*⍨+/×⍨⍵}→ {⍵÷.5*⍨(+/(×⍨⍵))}→ ⊢÷.5*⍨(+/(×⍨⊢))→ ⊢÷.5*⍨(+/(×⍨))→ →⊢÷.5*⍨(+/×⍨)

— Adám

(+/×⍨)->+.×⍨

— ngn

Answer 21

भूसी , 8 7 बाइट्स

´(Ṁ/√ṁ□

इसे ऑनलाइन आज़माएं!

Answer 22

C # (.NET Core) , 51 + 64 = 115 बाइट्स

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

इसे ऑनलाइन आज़माएं!

+64 बाइट्स के लिए using System;using System.Collections.Generic;using System.Linq;

सी # (.NET कोर) , 94 + 13 = 107 बाइट्स

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

इसे ऑनलाइन आज़माएं!

+13 बाइट्स के लिए using System;

गैर-लिनक दृष्टिकोण

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

Answer 23

पर्ल 5 , 45 + 1 ( -a) = 46 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 24

पिप , 10 बाइट्स

-pध्वज के लिए कोड के 9 बाइट्स, +1 ।

g/RT$+g*g

वेक्टर को अलग-अलग कमांड-लाइन तर्क के रूप में लेता है। इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

      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)

Answer 25

अजगर, 5 बाइट्स

cR.aQ

इसे ऑनलाइन आज़माएं: टेस्ट सूट

स्पष्टीकरण:

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

Answer 26

पर्ल 6 , 25 बाइट्स

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

इसे ऑनलाइन आज़माएं!

$_फ़ंक्शन के लिए सूची तर्क, »/»तत्वों के वर्गों के योग के वर्गमूल ( ) द्वारा तत्ववाचक ( ) विभाजित है »²।

Answer 27

रूबी, 39 35 बाइट्स

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

-4 बाइट्स जी बी के लिए धन्यवाद।

Comments

sum{...}map{...}.sum

— GB

Answer 28

एपीएल नार 12 वर्ण

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

Comments

आपको f← अपनी बाइट की गिनती में नहीं आना है, क्योंकि आप इसके बिना dfns का उपयोग कर सकते हैं। वैसे, √NARS में एक एकल बाइट है? मैं इसे से परिचित नहीं हूँ, इसलिए सिर्फ पूछ

— ऊरीएल

@ युरील नार्स अप्प कुछ ही में मुझे पता है कि यूनिकोड के साथ लिखेंगे इसलिए बाइट्स की संख्या 12x2 होनी चाहिए

— रोजल्यूप

Answer 29

Google शीट, 65 बाइट्स

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

इनपुट सूची Aप्रति कक्ष एक प्रविष्टि के साथ कॉलम में है । इस तरह से स्प्रेडशीट सामान्य रूप से सूचियों का उपयोग करेगी। दुर्भाग्य से, यह आम तौर ,0,0,0,0,0,....पर अंत में एक लंबी सूची का परिणाम होगा, इसलिए हमें उन लोगों को If Blank then Blank else Mathतर्क के साथ अनदेखा करना होगा ।

यदि यह सभी एक सेल में था, तो इसके बजाय, समाधान 95 बाइट्स होगा:

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

Answer 30

स्विफ्ट 4, 44 बाइट्स

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

हर घटक के लिए सदिश मान का पुनरावर्तन करता है, लेकिन कम से कम यह बहुत महत्वपूर्ण है!