रिवर्स मैथ्स साइकिल

18

से प्रेरित होकर इस

लिंक की गई चुनौती में, हमें मूल के तत्वों और इनपुट सरणी के रिवर्स के अलावा लागू करने के लिए कहा जाता है। इस चुनौती में, हम अन्य बुनियादी गणित कार्यों को शुरू करके इसे थोड़ा और कठिन बनाने जा रहे हैं।

पूर्णांक के एक सरणी को देखते हुए, चक्र के माध्यम से +, *, -, //, %, ^, जहां //पूर्णांक विभाजन है और ^प्रतिपादक है, जबकि इसे सरणी के विपरीत पर लागू करना है। या, दूसरे शब्दों में, सरणी के प्रत्येक तत्व के लिए उपरोक्त कार्यों में से एक को लागू करें, दूसरा तर्क सरणी के रिवर्स होने के साथ, फ़ंक्शन के साथ उपरोक्त सूची के माध्यम से सायक्लिंग लागू किया गया है। यह अभी भी भ्रमित हो सकता है, इसलिए एक उदाहरण के माध्यम से काम करने देता है।

Input:   [1, 2, 3, 4, 5, 6, 7, 8, 9]
Reverse: [9, 8, 7, 6, 5, 4, 3, 2, 1]

         [ 1,  2,  3,  4,  5,    6,  7,  8,  9]
Operand:   +   *   -   /   %     ^   +   *   -
         [ 9,  8,  7,  6,  5,    4,  3,  2,  1]

Result:  [10, 16, -4,  0,  0, 1296, 10, 16,  8]

इसलिए आउटपुट के लिए [1, 2, 3, 4, 5, 6, 7, 8, 9]होगा[10, 16, -4, 0, 0, 1296, 10, 16, 8]

कोने के मामलों को कवर करने के लिए, इनपुट में कभी 0 नहीं होगा, लेकिन इसमें नकारात्मक अनन्तता से सकारात्मक अनंत तक की सीमा में कोई अन्य पूर्णांक हो सकता है। यदि आप चाहते हैं कि आप अंकों का प्रतिनिधित्व करने वाले तारों की एक सूची के रूप में इनपुट ले सकते हैं।

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

input => output

[1, 2, 3, 4, 5, 6, 7, 8, 9]     => [10, 16, -4, 0, 0, 1296, 10, 16, 8]
[5, 3, 6, 1, 1]                 => [6, 3, 0, 0, 1]
[2, 1, 8]                       => [10, 1, 6]
[11, 4, -17, 15, 2, 361, 5, 28] => [39, 20, -378, 7, 2, 3.32948887119979e-44, 9, 308]

यह एक कोड-गोल्फ इतना छोटा कोड (बाइट्स में) जीतता है!

code-golf  number  arithmetic  array-manipulation 
— केर्ड सिक्काहिरिंग
स्रोत
सैंडबॉक्स (2k + केवल)
— caird coinheringaahing
@AdmBorkBork वह इसे संबोधित कर रहे हैं, मैंने बताया कि चैट में।
— श्री एक्सकोडर
@AdmBorkBork ने सही किया। मुझे याद आया कि मेरे टेस्ट केस जनरेटर में
— caird coinheringaahing
आपके तीसरे परीक्षण के मामले में अभी भी 0>।>
— श्री एक्सकोडर
1
@DigitalTrauma उन भाषाओं के लिए, जो पूर्णांकों के लिए डिफ़ॉल्ट हैं, मुझे लगता है कि आउटपुट 0 उस तरह की छोटी संख्या के लिए स्वीकार्य है।
— caird coinheringaahing

जवाबों:

6

जेली, 10 बाइट्स ( कांटा )

+×_:%*6ƭ"Ṛ

मैं दूसरे दिन इसके लिए त्वरित रूप से लागू करने पर काम कर रहा था, इसलिए इतनी जल्दी इसका उपयोग देखना काफी आश्चर्यजनक है। यह अभी भी केवल एक कांटे के रूप में मौजूद है, इसलिए आप इसे ऑनलाइन नहीं आज़मा सकते।

नमूना उत्पादन

$ ./jelly eun '+×_:%*6ƭ"Ṛ' '[1,2,3,4,5,6,7,8,9]'
[10, 16, -4, 0, 0, 1296, 10, 16, 8]
$ ./jelly eun '+×_:%*6ƭ"Ṛ' '[5,3,6,1,1]'
[6, 3, 0, 0, 1]
$ ./jelly eun '+×_:%*6ƭ"Ṛ' '[2,1,8]'
[10, 1, 6]
$ ./jelly eun '+×_:%*6ƭ"Ṛ' '[11,4,-17,15,2,361,5,28]'
[39, 20, -378, 7, 2, 3.32948887119979e-44, 9, 308]

व्याख्या

+×_:%*6ƭ"Ṛ  Input: array
      6ƭ    Tie 6 dyads
+             Addition
 ×            Multiplication
  _           Subtraction
   :          Integer division
    %         Modulo
     *        Power
        "   Vectorize with
         Ṛ  Reverse
— मील की दूरी पर
स्रोत
whaaaaaaaat वास्तव में आता है :( लेकिन अच्छा है, यह जल्दी काफी उपयोगी लगता है: D
— HyperNeutrino
इसके लिए जेली को खींचने की जरूरत है। +1 हालांकि आप ƭनिलाड्स (मूल्य बदलें) और मोनाड्स (बाएं तर्क पर लागू) का समर्थन करना चाहते हैं
— आउटगॉल्फ
@EriktheOutgolfer यह पहले से ही साधुओं के साथ काम करता है। जेली चैट में मेरे द्वारा पोस्ट किए गए उदाहरण देखें। निलाड एक अलग मामला है।
— मील
@ मीलों मेरा मतलब है कि कैसे निलाद यहाँ व्यवहार करते हैं ।
— आउटगॉल्फ
@EriktheOutgolfer Ok यह अब nilads का समर्थन करता है, लेकिन आपको उनकी लंबाई को परिभाषित करने और प्रत्येक के बीच एक स्थान का उपयोग करने की आवश्यकता है। उदाहरण 2 1”q3ƭ€पर [7,4,9,0]रिटर्न[2, 1, 'q', 2]
— मील
4

भूसी , 16 बाइट्स

यह चुनौती उन भाषाओं का पक्षधर है जो कार्यों की अनंत सूची बना सकती हैं। शायद नहीं, evalFTW

zF¢+ë+*-÷e%^Ṡze↔

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

कैसे?

  ¢+ë+*-÷e%^         The infinite list [+,*,-,÷,%,^,+,*,-,...
    ë+*-÷            The list [+,*,-,÷]
         e%^         The list [%,^]
   +                 Concatenated
  ¢                  Then repeated infinitely
               ↔     The input reversed e.g [9,8,7,6,5,4,3,2,1]
            Ṡze      Zipped with itself     [[9,1],[8,2],[7,3],[6,4],[5,5],[4,6],[3,7],[2,8],[1,9]]
zF                   Zipwith reduce, the list of functions and the list of lists.
                     [F+[9,1],F*[8,2],F-[7,3],F÷[6,4],F%[5,5],F^[4,6],F+[3,7],F*[2,8],F-[1,9]]
                     [10     ,16     ,-4     ,0      ,0      ,1296   ,10     ,16     ,8      ]

वैकल्पिक 17 बाइट समाधान:

ṠozIzI¢+ë+*-÷e%^↔
— H.PWiz
स्रोत
जिज्ञासा से बाहर, तुम क्यों नहीं कर सकते ë+*-÷%^? क्यों eजरूरी है?
— caird coinheringaahing
@cairdcoinheringaahing ë4 तर्क eलेता है , 2 लेता है। 6 के लिए एक नहीं है
— H.PWiz
3

05AB1E , 18 बाइट्स

Â"+*-÷%m"Ig×)øε`.V

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

व्याख्या

                    # push a reversed copy of the input
 "+*-÷%m"            # push the list of operators
         Ig×         # repeat it input times
            )ø       # zip together
              ε      # apply to each triplet
               `     # push separately to stack
                .V   # evaluate
— Emigna
स्रोत
Ig∍यदि आप "newish" कमांड का उपयोग करना चाहते हैं ( ∍यहाँ बहुत कुछ नहीं देखा है)।
— मैजिक ऑक्टोपस Urn
3

बैश + जीएनयू उपयोगिताओं, 53

tac $1|paste -d, $1 -|tr ',
' '
;'|paste -sd+*-/%^|bc

यह स्क्रिप्ट एक फ़ाइल नाम को कमांड-लाइन पैरामीटर के रूप में लेती है।

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

यहाँ अच्छी बात यह है कि paste -dविभाजकों की सूची दी जा सकती है, जिनका उपयोग चक्रीय रूप से किया जाता है। बाकी यह सिर्फ ऐसा करने के लिए सही प्रारूप में इनपुट प्राप्त करना है।

— डिजिटल आघात
स्रोत
अंतिम परीक्षण के मामले में असफल
— Shaggy
— डिजिटल ट्रॉमा
3

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

żṚj"“+×_:%*”ṁ$V

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

कैसे?

żṚj"“+×_:%*”ṁ$V - Link: list of numbers, a       e.g. [5, 3, 6, 1, 1]
 Ṛ              - reverse a                           [1, 1, 6, 3, 5]
ż               - interleave                          [[5,1],[3,1],[6,6],[1,3],[1,5]
             $  - last two links as a monad:
    “+×_:%*”    -   literal list of characters        ['+','×','_',':','%','*']
            ṁ   -   mould like a                      ['+','×','_',':','%']
   "            - zip with the dyad:
  j             -   join                              ["5+1","3×1","6_6","1:3","1%5"]
              V - evaluate as Jelly code (vectorises) [6, 3, 0, 0, 1]
— जोनाथन एलन
स्रोत
बाइट्स के एक जोड़े के साथ बचाओż“+×_:%*”;"ṚV
— एरिक आउटग्राफर
@EriktheOutgolfer केवल तभी काम करता है जब इनपुट की लंबाई ठीक 6. हो। मुझे लगता है कि आपको ऐसा करने की आवश्यकता होगी ż“+×_:%*”ṁ$;"ṚVजो 15 बाइट्स भी हो।
— जोनाथन एलन
ठीक है मैं क्या सोच रहा था ... मुझे "टाई" की याद आती है :(
— एरिक द आउटगलर
3

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

-3 बाइट्स ओव्स के लिए धन्यवाद।

lambda l:[eval(j+'*+*-/%*'[-~i%6::6]+l[~i])for i,j in enumerate(l)]

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

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

lambda l:[[add,mul,sub,div,mod,pow][i%6](v,l[~i])for i,v in enumerate(l)]
from operator import*

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

evalबुराई है ... लेकिन शायद अधिक गोल्फ। : पी

— totallyhuman
स्रोत
— ovs
2

जावास्क्रिप्ट (ईएस 7), 68 67 बाइट्स

a=>[...a].map((v,i)=>(x=a.pop(),o='+*-/%'[i%6])?eval(v+o+x)|0:v**x)

कोड स्निपेट दिखाएं

— Arnauld
स्रोत
अच्छा समाधान! हो सकता है कि आप कुछ बाइट्स को बचाने oके .pop()लिए कोष्ठकों के अंदर के असाइनमेंट को स्थानांतरित कर सकते हैं ।
— ल्यूक
@Luke को असाइनमेंट का oउपयोग टर्नरी ऑपरेटर की स्थिति के रूप में भी किया जाता है। इससे वह योजना टूट जाएगी।
— अरनुलद
@Shaggy। यह ठीक उसी तरह का पहला अरनुल्द का जवाब था।
@ ThePirateBay: आह। एसई मोबाइल पर इसलिए संपादित इतिहास नहीं देख सकते।
— झबरा
2

पर्ल 6 ,67 66 बाइट्स

@Nwellnhof को 1 बाइट धन्यवाद दिया।

{map {EVAL ".[0] {<+ * - div % **>[$++%6]} .[1]"},zip $_,.reverse}

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

बहुत अकल्पनीय (और शायद बुरा) समाधान। अपने आप से तर्क को उलट दिया। परिणामी सूची को तब EVALस्ट्रिंग के साथ मैप किया जाता है जो स्ट्रिंग है a (operator) b। ऑपरेटर को <+ * - div % **>फ्री का उपयोग करके स्ट्रिंग्स की सूची से चुना जाता है state( staticसी में सोचें - मूल्य ब्लॉक) चर के कॉल पर बनी रहती है$ । यह प्रत्येक ब्लॉक के लिए अलग से बनाया गया है और 0 पर सेट किया गया है। आप इसके साथ कुछ भी कर सकते हैं, लेकिन आप इसे केवल एक बार संदर्भित कर सकते हैं ( $वास्तव में किसी अन्य चर को संदर्भित करता है)। तो $++%6वास्तव में पहली कॉल के दौरान 0, दूसरी के दौरान 1, ... 6 वीं के दौरान 5, 7 वीं के दौरान 0 और इसी तरह।

मैं पहली बार में एक के बिना करने की कोशिश की EVAL। ऑपरेटर वास्तव में सिर्फ उप (= फ़ंक्शन) होते हैं, लेकिन उनके नाम इतने अस्वाभाविक ( &infix:<+>और इतने पर) हैं कि मुझे उस दृष्टिकोण से गुजरना पड़ा।

— Ramillies
स्रोत
map {EVAL ".[0] ... .[1]"},zip $_,.reverse1 बाइट छोटी है।
— nwellnhof
@nwellnhof, धन्यवाद!
— रामलीज
2

हास्केल , 74 117 105 बाइट्स

x#y=fromIntegral.floor$x/y
x%y=x-x#y
f u=[o a b|(o,a,b)<-zip3(cycle[(+),(*),(-),(#),(%),(**)])u(reverse u)]

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

@Nimi की बदौलत 12 बाइट्स बचाए

निश्चित रूप से इसे प्राप्त करने का एक बेहतर तरीका है।

EDIT 1. पूर्णांक के लिए निश्चित घातांक; 2. निश्चित रूप से एक बेहतर तरीका है, नीचे टिप्पणी देखें: 95 91 बाइट्स

x#y=fromIntegral.floor$x/y
x%y=x-x#y
f=zipWith3($)(cycle[(+),(*),(-),(#),(%),(**)])<*>reverse

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

— jferard
स्रोत
zipWith3($)(cycle[(+),(*),(-),div,mod,(^)])<*>reverseएक छोटा, अब आपका हटाया गया संस्करण है।
— H.PWiz
@ H.PWiz मैं ऐसा कुछ देख रहा था, लेकिन आगे देखने का समय नहीं था। आपने इसे क्यों हटाया? मेरा मानना ​​है कि एक ही भाषा में दो अलग-अलग समाधानों के लिए निषिद्ध नहीं है, खासकर जब एक दूसरे की तुलना में कहीं अधिक बेहतर होता है ...
— jferard
@ H.PWiz फिक्स्ड एक्सपोनेंट।
— 8
hके कॉल की कोई आवश्यकता नहीं है o: o a bऔर इसके बिना आप इनलाइन h( TIO ) कर सकते हैं ।
— nimi
1

जे, 44 42 बाइट्स

पार किया ४४, यदा यदा…

-2 बाइट्स की बदौलत @ ConorO'Brien

_2+/`(*/)`(-/)`(<.@%/)`(|~/)`(^/)\[:,],.|.

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

इतने सारे parens और आवेषण ... निश्चित रूप से ऐसा करने का एक बेहतर तरीका है (शायद infix के बजाय सम्मिलित का उपयोग कर रहे हैं?)

व्याख्या

_2(+/)`(*/)`(-/)`(<.@%/)`(|~/)`(^/)\[:,],.|.  Input: a
                                       ],.|.  Join a with reverse(a)
                                      ,       Ravel (zip a with reverse(a))
_2                                 \          To non-overlapping intervals of 2
  (+/)`(*/)`(-/)`(<.@%/)`(|~/)`(^/)           Apply the cyclic gerund
   +/                                           Insert addition
        */                                      Insert subtraction
             -/                                 Insert division 
                  <.@%/                         Insert integer division
                          |~/                   Insert mod
                                ^/              Insert exponentiation

कुछ नोट:

J का पूर्णांक विभाजन नहीं है, इसलिए हम %-floor के साथ -डिविज़न की रचना करते हैं >.। J का मॉड ( |) हम क्या चाहते हैं, का उल्टा क्रम करता है, इसलिए ~हमें-coslexive का उपयोग करके इसके ऑर्डर को पलटना होगा।

भले ही हम 2 के अंतराल पर आगे बढ़ रहे हैं, हमें /-insert का उपयोग करने के लिए क्रियाओं को सम्मिलित करना होगा ताकि उन्हें रंग-रूप से उपयोग किया जा सके क्योंकि \-infix कैसे काम करता है।

— गोभी
स्रोत
मैं यह भी जानना चाहूंगा कि कैसे ()और सभी से बचने के लिए /- मैं यह पता लगाने में सक्षम नहीं था ....
— योना
@ जोनाह, सबसे अच्छा मैं सोच सकता हूं कि कुछ /उल्टा सरणी पर है (क्योंकि यह पीछे की ओर संचालित होता है ...) जैसे क्रिया के साथ (,+)`(,*)लेकिन यह बहुत मदद नहीं करता है ... (यह भी काम नहीं करता है)
— कोल
1
गेरुंड हो सकता है+/`(*/)`...
— कॉनर ओ'ब्रायन
1

रूबी , 63 57 बाइट्स

->a{t=0;a.map{|x|eval [x,a[t-=1]]*%w(** % / - * +)[t%6]}}

कुछ भी नहीं फैंसी, वास्तव में। सरणी पर बस पुनरावृत्त करें, रिवर्स इंडरेटर के रूप में एक सूचकांक का उपयोग करें, सही ऑपरेटर का उपयोग करके स्ट्रिंग में शामिल हों, मूल्यांकन करें, कुल्ला और दोहराएं।

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

— जीबी
स्रोत
1

k , 40 बाइट्स

{_((#x)#(+;*;-;%;{y!x};{*/y#x})).'x,'|x}

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

{                                      } /function(x)
                                     |x  /reverse x
                                  x,'    /zip concat with x
        ( ; ; ; ;     ;       )          /list of operations
         + * - %                         /add, mult, sub, div
                 {y!x}                   /mod (arguments need to be reversed)
                       {*/y#x}           /pow (repeat and fold multiply)
  ((#x)#                       )         /resize operations to length of x
                                .'       /zip apply
 _                                       /floor result
— zgrep
स्रोत
1

MATL ,27 23 बाइट्स

-4 बाइट्स @LuisMendo को धन्यवाद

tP+1M*1M-IM&\w1M^v"@X@)

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

स्पष्टीकरण:

tP         % duplicate and flip elements
+          % push array of sums (element-wise)
1M*        % push array of products (element-wise)
1M-        % push array of subtractions (element-wise)
IM&\w      % push array of divisions and modulo (element-wise)
1M^        % push array of power (element-wise)
v          % vertically concatenate all arrays
"@X@)    % push to stack values with the correct index based on operator
           % (implicit) convert to string and display
— Cinaski
स्रोत
0

आर , 74 बाइट्स

function(l)Map(Map,c(`+`, `*`, `-`, `%/%`, `%%`,`^`),l,rev(l))[1:sum(l|1)]

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

यह अंतिम उत्तर है जिसके साथ मैं आया था। यह लंबाई की एक सूची देता है length(l)जहां प्रत्येक तत्व एक सूची होती है जिसमें संबंधित तत्व होता है। Kinda गंदे लेकिन वे सब वहाँ हैं। यदि यह अस्वीकार्य है, तो दोनों को Mapबदल दिया जा सकता हैmapply +3 बाइट्स के ।

चूंकि आर ऑपरेटर सभी फ़ंक्शन हैं (इन्फिनिटी संकेतन सिर्फ सिंटैक्टिक शुगर है), मैंने एक सूची से एक का चयन करने की कोशिश की; उदाहरण के लिए, नीचे 94 बाइट समाधान।

कोशिश करने और लूप से छुटकारा पाने के लिए, मैंने कोशिश की sapply, लेकिन वह केवल एक ही फ़ंक्शन और इनपुट सूची के साथ काम करता है। फिर मुझे बहुभिन्नरूपी रूप याद आया mapply, जो एक n-aryफ़ंक्शन लेता है FUNऔर nतर्कों को सफल करता है, FUNपहले, दूसरे, ..., तर्कों के प्रत्येक के तत्वों पर लागू होता है, यदि आवश्यक हो तो रीसाइक्लिंग । एक रैपर फंक्शन भी है mapply, Mapजो "परिणाम को सरल बनाने के लिए कोई प्रयास नहीं करता है" । चूंकि यह तीन बाइट्स छोटा है, इसलिए यह एक अच्छा गोल्फिंग अवसर है।

इसलिए मैंने एक त्रिकोणीय फ़ंक्शन (नीचे दिए गए 80 बाइट समाधान के रूप में) को परिभाषित किया जो एक फ़ंक्शन को पहले तर्क के रूप में लेता है, और इसे अपने दूसरे और तीसरे वाले पर लागू करता है। हालांकि, मुझे एहसास हुआ किMap यह एक ऐसा फंक्शन है जो किसी फ़ंक्शन को उसके पहले तर्क के रूप में लेता है और उसे क्रमिक रूप से लागू करता है। साफ!

अंत में, हम अंत में यह सुनिश्चित करते हैं कि हम केवल पहले length(l)मान लौटाएँ।

आर , 80 बाइट्स

function(l)Map(function(x,y,z)x(y,z),c(`+`, `*`, `-`, `%/%`, `%%`,`^`),l,rev(l))

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

यह काम नहीं करता है, क्योंकि यह 6 से कम तत्वों वाले सूचियों के लिए 6 मान लौटाएगा।

आर , 94 बाइट्स

function(l){for(i in 1:sum(l|1))T[i]=switch(i%%6+1,`^`,`+`,`*`,`-`,`%/%`,`%%`)(l,rev(l))[i]
T}

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

स्पष्टीकरण (सौम्य रूप से अपवित्र):

function(l){
 for(i in 1:length(l)){
  fun <- switch(i%%6+1,`^`,`+`,`*`,`-`,`%/%`,`%%`) # select a function
  res <- fun(l,rev(l))                             # apply to l and its reverse
  T[i] <- res[i]                                   # get the i'th thing in the result
 }
 T                                                 # return the values
}

क्योंकि प्रत्येक फ़ंक्शन को वेक्टर किया जाता है, हम अंत में इंडेक्स कर सकते हैं ( res[i])। यह evalनीचे दिए गए दृष्टिकोण से बेहतर है ।

आर , 100 बाइट्स

function(l)eval(parse(t=paste("c(",paste(l,c("+","*","-","%/%","%%","^"),rev(l),collapse=","),")")))

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

यह सबसे छोटा evalतरीका है जो मुझे मिल सकता है; क्योंकि हम एक वेक्टर में परिणामों को एकत्र करने के लिए, हम की जरूरत है pasteएक c( )जो अनावश्यक बाइट्स की एक टन कहते हैं चारों ओर भाव,

— ग्यूसेप
स्रोत
0

कैसियो-बेसिक, 108 बाइट्स

{x+y,x*y,x-y,int(x/y),x-int(x/y)y,x^y}⇒o
dim(l)⇒e
Print seq(o[i-int(i/6)6+1]|{x=l[i+1],y=l[e-i]},i,0,e-1)

यह दर्दनाक था। विशेष रूप से क्योंकि mod(x,y)रिटर्न xजब यह वास्तव में नहीं होना चाहिए, जिसका मतलब है कि मुझे अपना मॉड फ़ंक्शन करना था: इसलिए x-int(x/y)y।

i0 से लूप्स length(l)-1, oसूची में क्रमिक तत्वों को लेने और के l[i]लिए xऔर इसके l[-i]लिए आवेदन करना y। (नकारात्मक सूचकांक हालांकि काम नहीं करते हैं, इसलिए इसके बजाय मैं घटाता हूंi सूची की लंबाई से और उस सूचकांक को लेता ।)

फ़ंक्शन के लिए 107 बाइट्स, lपैरामीटर बॉक्स में जोड़ने के लिए +1 बाइट ।

— numbermaniac
स्रोत
0

जावा 8, 336 बाइट्स

import java.math.*;a->{int b[]=a.clone(),i=0,l=b.length,s,t;for(;i<l/2;b[i]=b[l+~i],b[l+~i++]=t)t=b[i];BigInteger r[]=new BigInteger[l],u,v;for(i=-1;++i<l;t=b[i],v=new BigInteger(t+""),r[i]=(s=i%6)<1?u.add(v):s<2?u.multiply(v):s<3?u.subtract(v):s<4?u.divide(v):s<5?u.remainder(v):t<0?u.ZERO:u.pow(t))u=new BigInteger(a[i]+"");return r;}

इसे यहाँ आज़माएँ।

आह ..
इनपुट के रूप मेंint[] , आउटपुट के रूप मेंjava.math.BigInteger[] ।

नियम के बिना " कोने मामलों को कवर करने के लिए, इनपुट एक 0 में शामिल होंगे कभी नहीं, लेकिन सकारात्मक अनंत को नकारात्मक अनन्तता से रेंज में किसी भी अन्य पूर्णांक हो सकती है। ", रेंज में पूर्णांकों का उपयोग कर -2147483648के लिए 2147483647, यह होगा 186 बाइट्स (इनपुट क्योंकि int[], और कोई आउटपुट नहीं क्योंकि यह बाइट को बचाने के बजाय इस इनपुट-सरणी को संशोधित करता है):

a->{int b[]=a.clone(),i=0,l=b.length,t,u,v;for(;i<l/2;b[i]=b[l+~i],b[l+~i++]=t)t=b[i];for(i=-1;++i<l;v=b[i],a[i]=(t=i%6)<1?u+v:t<2?u*v:t<3?u-v:t<4?u/v:t<5?u%v:(int)Math.pow(u,v))u=a[i];}

इसे यहाँ आज़माएँ।

स्पष्टीकरण:

import java.math.*;            // Required import for BigInteger

a->{                           // Method with int[] parameter and BigInteger[] return-type
  int b[]=a.clone(),           //  Make a copy of the input-array
      i=0,                     //  Index-integer
      l=b.length,              //  Length of the input
      s,t;                     //  Temp integers
  for(;i<l/2;b[i]=b[l+~i],b[l+~i++]=t)t=b[i];
                               //  Reverse the input-array and store it in `b`
  BigInteger r[]=new BigInteger[l],
                               //  Result-array
             u,v;              //  Temp BigIntegers
  for(i=-1;                    //  Reset `i` to -1
      ++i<l;                   //  Loop over the array(s):
                               //    After every iteration:
      t=b[i],                  //     Set the current item of `b` in `t`
      v=new BigInteger(t+""),  //     And also set it in `v` as BigInteger
      r[i]=(s=i%6)<1?          //   If the index `i` modulo-6 is 0:
            u.add(v)           //    Add the items with each other
           :s<2?               //   Else-if index `i` modulo-6 is 1:
            u.multiply(v)      //    Multiply the items with each other
           :s<3?               //   Else-if index `i` modulo-6 is 2:
            u.subtract(v)      //    Subtract the items with each other
           :s<4?               //   Else-if index `i` modulo-6 is 3:
            u.divide(v)        //    Divide the items with each other
           :s<5?               //   Else-if index `i` modulo-6 is 4:
            u.remainder(v)     //    Use modulo for the items
           :                   //   Else (index `i` modulo-6 is 5):
            t<0?               //    If `t` is negative:
             u.ZERO            //     Simply use 0
            :                  //    Else:
             u.pow(t))         //     Use the power of the items
    u=new BigInteger(a[i]+""); //  Set the current item of `a` to `u` as BigInteger
                               //  End of loop (implicit / single-line body)
  return r;                    //  Return the result BigInteger-array
}                              // End of method
— केविन क्रूज़सेन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.