एक सरणी में एक लहर लागू करें

24

आज आपका कार्य संख्याओं की एक लहर पर लागू करना है। एक लहर इस तरह दिखती है: [1, 0, -1, 0, 1, 0, -1, 0, 1...]इसे दिए गए सरणी पर लागू करने का मतलब है कि पहले तत्वों, दूसरे तत्वों, आदि को एक साथ जोड़ना।

ज्यादा ठीक:

आपके कार्यक्रम या फ़ंक्शन को पूर्णांकों की एक सरणी प्राप्त होगी। इसे 1मूल सरणी के 1, 5 वें, 9 वें आदि तत्व के साथ समान आकार के सरणी को प्रिंट या वापस करना होगा , मूल सरणी -1के तीसरे, 7 वें, 11 वें आदि तत्व और बाकी तत्वों में जोड़ा जाना चाहिए। अछूता छोड़ दिया जाना चाहिए।

इनपुट सरणी में कम से कम एक तत्व होने की गारंटी है।

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

Input                               | Output
[0]                                 | [1]
[-1]                                | [0]
[-4, 3, 0, 1, 7, 9, 8, -2, 11, -88] | [-3, 3, -1, 1, 8, 9, 7, -2, 12, -88]
[0, 0, 0, 0, 0]                     | [1 ,0 ,-1 ,0 ,1]
[1, 1]                              | [2, 1]

यह कोड-गोल्फ है , सबसे छोटा कोड जीतता है!

code-golf  array-manipulation 
— पावेल
स्रोत
कुछ हद तक अस्पष्ट रूप से, कई समाधान काल्पनिक संख्या जादू का उपयोग कर रहे हैं ...
— पावेल
2
यह समझ में आता है कि काल्पनिक संख्याएं क्यों उपयोगी होंगी, यह एक लहर की समस्या है और काल्पनिक संख्याओं में ध्रुवीय गुणों का एक अच्छी तरह से प्रलेखित इतिहास है। काल्पनिक संख्या विशेष रूप से पूर्णांक क्वार्टर घुमावों के लिए साइन और कोजाइन की गणना करने का सुंदर गोल्फ तरीका हो सकता है। मस्त है मस्त ...
— गेहूं के जादूगर
3
@WheatWizard यह एक बहुत बड़ा अनुपात है जिसे ज्यादातर भाषाओं ने काल्पनिक संख्या के लिए समर्थन नहीं दिया है।
— पावेल

जवाबों:

8

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

Jı*Ċ+

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

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

Jı*Ċ+  Main link. Argument: A (array)

J      Indices; yield [1, ..., len(A)].
 ı*    Elevate the imaginary unit to the power 1, ..., len(A), yielding
       [0+1i, -1+0i, 0-1i, 1+0i, ...].
   Ċ   Take the imaginary part of each result.
    +  Add the results to the corresponding elements of A.
— डेनिस
स्रोत
लीकी नून को क्या मिला: चाट.स्टैकएक्सचेंज.com
— Pavel
1
कोई स्पष्टीकरण?
— प्यूरफेरेट
1
@ काल्पनिक संख्या की क्रमिक शक्तियों के काल्पनिक भाग को मैं प्रत्येक तत्व में जोड़ देता हूं
— Cœur
@ कूर वह है 1, 2, 3 ...या 1, 0, -1, 0 ...?
— प्यूरफेरेट
1
में जवाब के रूप में एक ही स्पष्टीकरण @Pureferret Matl या Math.JS या Mathematica या आर या ...
— कोयूर
14

लोगो , 18 बाइट्स

[map[?+sin 90*#]?]

कोई "इसे ऑनलाइन आज़माएं!" लिंक क्योंकि सभी ऑनलाइन लोगो दुभाषिया टेम्पलेट-सूची का समर्थन नहीं करता है।

यह एक टेम्प्लेट-सूची (अन्य भाषाओं में लैम्बडा फ़ंक्शन के बराबर) है।

उपयोग:

pr invoke [map[?+sin 90*#]?] [-4 3 0 1 7 9 8 -2 11 -88]

( invokeफ़ंक्शन को कॉल करता है, prपरिणाम प्रिंट करता है)

प्रिंट करता है [-3 3 -1 1 8 9 7 -2 12 -88]।

स्पष्टीकरण (पहले से ही समझने योग्य):

 map[?+sin 90*#]?       map a function over all the items of the input
              #         the 1-based index of the element in the input
       sin 90*#         equal to the required wave
     ?                  looping variable
     ?+sin 90*#         add the wave to the input
— user202729
स्रोत
हह, मुझे पता था कि कोई व्यक्ति साइन-आधारित उत्तर के साथ आएगा।
— ETHproductions
2
@ETHproductions मैथेमेटिका में पहला जवाब, शाइन पर आधारित था जब तक कि इसे नीचे नहीं उतारा गया था। आर में दूसरा उत्तर साइन का उपयोग करके स्टिल है।
— पावेल
1
@Phoenix मैं हैरान हूँ कि मैंने ध्यान नहीं दिया ...
— ETHproductions
@ETHproductions और .... साइन को R उत्तर से भी बाहर कर दिया गया है। मुझे लगता है कि यह वही काम कर रहा है जो गणितज्ञ जवाब के रूप में करते हैं।
— पावेल
9

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

a=>a.map((x,i)=>x-(i%4-1)%2)

गणना इस प्रकार है:

i%4  -1  %2
0    -1  -1
1     0   0
2     1   1
3     2   0

तथ्य यह है कि जे एस में, जब संग्राहक ऋणात्मक संख्या (यानी अपनी ऋणात्मक चिह्न रख सकेंगे के अंतिम बिट लेने लाभ -5 % 3 -> -2, बजाय 1के रूप में यह अजगर में होगा)।

— ETHproductions
स्रोत
9

गणितज्ञ, २६ २३ २२ बाइट्स

Im[I^Range@Tr[1^#]]+#&

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

नोट: TIO लिंक 23-बाइट संस्करण के लिए है, 22-बाइट संस्करण मैथिक्स-संगत नहीं है।

— user202729
स्रोत
नीचे एक 19-बाइट मैथमेटिका समाधान है (प्रारंभ के 4 बाइट्स के साथ)
— user202729
8

MATL , 11 8 बाइट्स

Jyn:^Yj+

MATL ऑनलाइन पर यह कोशिश करो !

व्याख्या

J     % Push 1j (imaginary unit)
      % STACK; 1j
y     % Implicit input. Duplicate from below
      % STACK: [-4 3 0 1 7 9 8 -2 11 -88], 1j, [-4 3 0 1 7 9 8 -2 11 -88]
n     % Number of elements
      % STACK: [-4 3 0 1 7 9 8 -2 11 -88], 1j, 10
:     % Range
      % STACK: [-4 3 0 1 7 9 8 -2 11 -88], 1j, [1 2 3 4 5 6 7 8 9 10]
^     % Power, element-wise
      % STACK: [-4 3 0 1 7 9 8 -2 11 -88], [1j -1 -1j 1 1j -1 -1j 1 1j -1]
Yj    % Imaginary part
      % STACK: [-4 3 0 1 7 9 8 -2 11 -88], [1 0 -1 0 1 0 -1 0 1 0]
+     % Add, element-wise. Implicit display
      % STACK: [-3 3 -1 1 8 9 7 -2 12 -88]
— लुइस मेंडो
स्रोत
उम, आप +स्पष्टीकरण में जोड़ना भूल गए
— caird coinheringaahing
@cairdcoinheringaahing धन्यवाद, संपादित
— लुइस
3

जेली , 16 बाइट्स

-1Jm2$$¦+2Jm4$$¦

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

हे मुझे यकीन है कि यह बहुत लंबा है

संपादित करें

मुझे पता है कि एक 5 बाइट समाधान संभव है, लेकिन मेरी वाईफ़ाई मुझे काट देना शुरू कर देती है इसलिए मैं कल इसे गोल्फ करूंगा। अगर कोई इससे पहले कि मैं इसे गोल्फ कर सकता हूं, लघु जेली समाधान पोस्ट करता है, तो यह मेरे साथ ठीक है; मैं इसे सिर्फ संदर्भ के लिए यहां रखूंगा कि मैं जेली पर कितना बुरा हूं, इसे करने का दूसरा तरीका। मेरा मतलब है, मैं सिर्फ लिंक फीनिक्स को टिप्पणियों में पोस्ट कर सकता हूं , लेकिन जब से मैं सीख रहा हूं, मैं समाधान को नहीं देखना चाहता हूं, जब तक कि मैं खुद को समझ नहीं लेता। इससे मुझे प्रतिष्ठा मिल सकती है, लेकिन सीखने के लिए मैं यहां मौजूद हूं :)))

— HyperNeutrino
स्रोत
LeakyNun ने इसे चैट में 5 में किया: Spoiler
— Pavel
5
ओह .__________
— २.३३१ पर हाइपरनेत्रिनो
डेनिस मिल गया: codegolf.stackexchange.com/a/135145/60042
— पावेल
3

पायथन 2 , 50 42 बाइट्स

सहेजे गए 8 बाइट्स @Sisyphus की बदौलत!

lambda l:map(sum,zip(l,[1,0,-1,0]*len(l)))

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

53 बाइट्स

lambda l:[int(x+(1j**i).real)for i,x in enumerate(l)]

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

— musicman523
स्रोत
lambda l:map(sum,zip(l,[1,0,-1,0]*len(l)))पायथन 2 के लिए
— सिप्फीस
अच्छा है, कि पायथन 3 में 5 बाइट्स बचाता है और फिर पायथन 2 में 3 और। धन्यवाद!
— संगीतकार ५२३
3

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

@ मीगो ने मुझे इस समाधान के लिए हराया

zipWith(+)$cycle[1,0,-1,0]

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

यह वही है जो हास्केल महान है। यह एक बिंदु-मुक्त फ़ंक्शन की घोषणा करता है जो एक अनंत सूची के साथ इनपुट को ज़िप करता है।

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

यहां एक समाधान है जो जटिल संख्याओं का उपयोग करता है। आयात की वजह से बहुत प्रतिस्पर्धात्मक नहीं है लेकिन कभी भी कम सुंदर नहीं था।

import Data.Complex
zipWith((+).realPart.((0:+1)^))[0..]

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

— गेहूं का जादूगर
स्रोत
2
EEK! आप निंजा मुझे 20 सेकंड के लिए चाहते हैं!
— मेगो
दो समान समाधान होने का कोई मतलब नहीं है। चूँकि आपने बिना किसी सुधार के मेरा सुधार किया और हमारे उत्तरों को समान बनाया, तो क्या आप उसे हटा देंगे?
— मेगो
3

मैथेमेटिका, 19 बाइट्स

i=1;#+Im[i*=I]&/@#&

व्याख्या

i=1;#+Im[i*=I]&/@#&
i=1;                 (* set variable i to 1 *)
               /@#   (* iterate through the input: *)
    #+Im[i   ]&      (* add the imaginary component of i... *)
          *=I        (* multiplying i by the imaginary unit each iteration *)

नोट: i=1फ़ंक्शन के बाहर दिखाई देता है, जो इस मेटा सर्वसम्मति के अनुसार ठीक है ।

— जंगहवान मिन
स्रोत
लेकिन तब फ़ंक्शन आवश्यक रूप से पुन: प्रयोज्य नहीं है (यदि फ़ंक्शन के एक कॉल के बाद iका मूल्य 1 से भिन्न है)
— user202729
@ user202729 मेटा आम सहमति मैं विशेष रूप से उस मुद्दे से संबंधित है। किसी फ़ंक्शन के बाहर वैश्विक चर घोषित करना ठीक है।
— जुंगह्वान मिन
3

जे, 12 बाइट्स

+1 0 _1 0$~#

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

क्योंकि J का शेप ऑपरेटर $साइक्लिकल रूप से भरता है, जब हम इसे #इनपुट की लंबाई तक आकार देते हैं , तो यह ठीक वैसा ही होता है जैसा हम चाहते हैं, और हम इसे इनपुट में जोड़ सकते हैं]

— जोनाह
स्रोत
आप पहले बाइट को छोड़ कर एक बाइट बचा सकते हैं] (यानी हुक का उपयोग करें)
— टिककनज़
@Tikkanz अच्छा कैच। मैंने पोस्ट अपडेट कर दी है।
— योना
3

सी ++, 93 85 83 63 बाइट्स

auto w=[](auto&i){for(int j=0;j<i.size();j+=2)i[j]+=j%4?-1:1;};

-8 बाइट्स, इस जवाब के लिए धन्यवाद , मैंने पाया कि लैम्ब्डा पैरामीटर हो सकते हैं autoऔर आप सही पैरामीटर के साथ पास कर सकते हैं, यह काम करेगा

-2 बाइट्स नेवे का धन्यवाद

-2 बाइट्स Zacharý की बदौलत

मैं हटा दिया vectorशामिल हैं। आपको निम्न स्थितियों का सम्मान करने वाले वा कंटेनर के तर्क के रूप में पारित करना होगा:

  • एक विधि है sizeजिसमें कोई तर्क नहीं है
  • सबस्क्रिप्ट ऑपरेटर को अधिभारित किया है

एसटीएल कंटेनरों निम्न शर्तों का सम्मान कर रहे हैं array, vector, string, map, unordered_map, और शायद दूसरों

यदि तर्कों को संशोधित करके आउटपुट देना अनुमति नहीं है, तो:

सी ++, 112 110 बाइट्स

#include<vector>
std::vector<int>w(std::vector<int>i){for(int j=0;j<i.size();j+=2)i[j]+=(j%4)?-1:1;return i;}
— HatsuPointerKun
स्रोत
1
आपका पहला एक है वैध आई / ओ।
— पावेल
1
आप j%42 बाइट बचाने के लिए उपयोग कर सकते हैं ।
— नेवले जूल
1
मुझे नहीं लगता कि आपको चारों ओर परेंस की जरूरत है j%4।
— Zacharý
2

दिल्लोग एपीएल, 13 बाइट्स

⊢+1 0 ¯1 0⍴⍨≢

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

कैसे?

1 0 ¯1 0 - सरणी [1, 0, -1, 0]

⍴⍨≢ - इनपुट, चक्रीय की लंबाई में फेरबदल

⊢+ - इनपुट के साथ सदिश राशि

— Uriel
स्रोत
2

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

{((1+0i,*×i...*)Z+$_)».re}

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

1+0i, * × i ... *1, i, -1, -iएक चक्र में दोहराई गई संख्याओं की एक अनंत सूची बनाता है। उन नंबरों को Z+इनपुट लिस्ट ( $_) के साथ जोड़ दिया जाता है , और फिर परिणामी कॉम्प्लेक्स नंबरों के वास्तविक घटकों को निकाला जाता है ( ».re)।

— शॉन
स्रोत
2

जाप , 11 10 बाइट्स

जाप के इंडेक्स रैपिंग का फायदा उठाता है।

Ë+[1TJT]gE

झसे आज़माओ

व्याख्या

सरणी का निहित इनपुट U।

Ë

सरणी पर नक्शा।

+

वर्तमान तत्व को जोड़ने के लिए ...

gE

वर्तमान सूचकांक में तत्व ( E) ...

[1TJT]

सरणी में [1,0,-1,0]।

— झबरा
स्रोत
1

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

.e+bss^.j)k

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

— deltaepsilon3
स्रोत
उसी बाइट की गिनती के साथ एक और समाधान के साथ आया:.e+b@[1Z_1Z
— ताली
बदलें ssके साथ eके लिए -1।
— निकोल
क्या वह काम करता है? .e+be^.j)kजब मैंने कोशिश की तो यह काम नहीं किया।
— डेल्टेप्सिलिलोन 3
1

गणित.जेएस , 34 बाइट्स

f(k)=k.map(j(x,y,z)=x+im(i^y[1]))

व्याख्या की

f(k)=k.map(j(x,y,z)=x+im(i^y[1]))
f(k)=                               # Define a function f, which takes argument k.
     k.map(                     )   # Map k to a function
           j(x,y,z)=                # Function j. Takes arguments x, y, and z. Where x is the item, y is the index in the form [i], and z is the original list.
                      im(      )    # The imaginary component of...
                         i^y[1]     # i to the power of the index.
                    x+              # x +, which gives our wave.

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

— Ataco
स्रोत
1

8 वें , 96 63 बाइट्स

कोड

a:new swap ( swap 90 * deg>rad n:cos int + a:push ) a:each drop

यह कोड TOS पर परिणामी सरणी छोड़ता है

उपयोग और उदाहरण

ok> [0,0,0,0,0] a:new swap ( swap 90 n:* deg>rad n:cos n:int n:+ a:push ) a:each drop .
[1,0,-1,0,1]

ok> [-4,3,0,1,7,9,8,-2,11,-88] a:new swap ( swap 90 * deg>rad n:cos int + a:push ) a:each drop .
[-3,3,-1,1,8,9,7,-2,12,-88]

व्याख्या

हम सही क्रम पाने के लिए cos (x) का उपयोग करते हैं [1,0, -1,0]। प्रत्येक ऐरे एलिमेंट के इंडेक्स को 90 डिग्री से गुणा किया जाता है और फिर इसे इच्छित "वेव फैक्टर" को संबंधित आइटम में जोड़ने के लिए cos () फंक्शन में पास किया जाता है।

: f \ a -- a
  a:new    \ create output array
  swap     \ put input array on TOS
  \ array element's index is passed to cos in order to compute
  \ the "wave factor" to add to each item
  ( swap 90 n:* deg>rad n:cos n:int n:+ 
  a:push ) \ push new item into output array 
  a:each
  drop     \ get rid of input array and leave ouput array on TOS
;
— अराजकता मनोर
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.