বিপরীত গণিত চক্র


18

দ্বারা অনুপ্রাণিত এই

লিঙ্কযুক্ত চ্যালেঞ্জে, আমরা মূল এবং ইনপুট অ্যারের বিপরীতে উপাদান যোগ করতে অনুরোধ জানানো হয়। এই চ্যালেঞ্জের মধ্যে, আমরা অন্যান্য বেসিক গণিত ক্রিয়াকলাপগুলি প্রবর্তন করে একে আরও জটিল করে তুলছি।

অ্যারের বিপরীতে প্রয়োগ করার সময় পূর্ণসংখ্যার একটি অ্যারে দেওয়া হয় +, *, -, //, %, ^, //এটি দিয়ে আবর্তিত হয় যেখানে পূর্ণসংখ্যা বিভাগ হয় এবং ^ঘনিষ্ট হয়। অথবা, অন্য কথায় উপরের তালিকার মাধ্যমে সক্রিয়ভাবে ফাংশন প্রয়োগ করে দ্বিতীয় যুক্তি অ্যারের বিপরীত হওয়া অ্যারের প্রতিটি উপাদানগুলিতে উপরের একটি ফাংশন প্রয়োগ করুন apply এটি এখনও বিভ্রান্তিকর হতে পারে, সুতরাং একটি উদাহরণ দিয়ে কাজ করতে দিন।

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 থাকে না তবে এতে নেতিবাচক অনন্ত থেকে ইতিবাচক অনন্ততা পর্যন্ত কোনও অন্য পূর্ণসংখ্যা থাকতে পারে contain আপনি চাইলে অঙ্কগুলি উপস্থাপন করে এমন স্ট্রিংগুলির তালিকা হিসাবে আপনি ইনপুট নিতে পারেন।

পরীক্ষার মামলা

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]

এটি একটি তাই সংক্ষিপ্ততম কোড (বাইটে) জয়!



@ অ্যাডমবার্কবার্ক তিনি এটিকে সম্বোধন করছেন, আমি আড্ডায় তা উল্লেখ করেছি।
মিঃ এক্সকোডার

@ অ্যাডমবর্কবর্ক সংশোধন করেছেন। আমি মিস করেছি যে আমার পরীক্ষার ক্ষেত্রে জেনারেটর
সিয়ারড কোইনরিঙ্গিংহিং

আপনার তৃতীয় পরীক্ষার
কেসটিতে

1
পূর্ণাঙ্গের ডিফল্ট ভাষাগুলির জন্য @ ডিজিটালট্রামা, আমি মনে করি 0 এর মতো ক্ষুদ্র সংখ্যার জন্য আউটপুট প্রদান গ্রহণযোগ্য।

উত্তর:


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

Whaaaaaaat আসুন সত্যই :( তবে দুর্দান্ত, এই
দ্রুতটি

এই প্রয়োজন জেলি টানা হবে। +1 যদিও আপনি ƭনীলাড (মান প্রতিস্থাপন) এবং মনাদ (বাম যুক্তিতে প্রয়োগ করুন) সমর্থন করতে চান
এরিক দ্য আউটগল্ফার

@ এরিকথ আউটগল্ফার এটি ইতিমধ্যে মনডের সাথে কাজ করে। জেলি চ্যাটে পোস্ট করা উদাহরণগুলি দেখুন। নীলাদ একটি আলাদা কেস।
মাইল মাইল

@ মাইলস আমার অর্থ ঠিক যেমন নীলাডরা এখানে আচরণ করে ।
এরিক আউটগলফার

@ এরিকথিউটগল্ফার ঠিক আছে এটি এখন নীলাদকে সমর্থন করে তবে আপনাকে তাদের দৈর্ঘ্য সংজ্ঞায়িত করতে হবে এবং প্রত্যেকটির মধ্যে একটি স্থান ব্যবহার করতে হবে। উদাহরণ 2 1”q3ƭ€উপর [7,4,9,0]আয়[2, 1, 'q', 2]
মাইল

4

হুশ , 16 বাইট

এই চ্যালেঞ্জটি এমন ভাষাগুলির পক্ষপাতী যা ফাংশনের অসীম তালিকা তৈরি করতে পারে। হয়তো না, evalএফটিডাব্লু

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%^↔

কৌতূহলের বাইরে আপনি কেন পারবেন না ë+*-÷%^? কেন eপ্রয়োজনীয়?
কেয়ার্ড কোইনরিঙ্গিংহহিং

@cairdcoinheringaahing ë4 আর্গুমেন্ট লাগে, eলাগে 2. আছে 6 জন্য এক নয়
H.PWiz

3

05 এ বি 1 ই , 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

Ig∍যদি আপনি "newish" কমান্ডটি ব্যবহার করতে চান তবে ( এখানে খুব বেশি কিছু দেখা যায় নি )।
ম্যাজিক অক্টোপাস উরন

3

বাশ + জিএনইউ ইউটিলিটিস, 53

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

এই স্ক্রিপ্টটি কমান্ড-লাইন প্যারামিটার হিসাবে একটি ফাইলের নাম নেয়।

এটি অনলাইনে চেষ্টা করুন

এখানে সুন্দর জিনিসটি paste -dপৃথককারীদের একটি তালিকা দেওয়ার অনুমতি দেয় যা চক্রাকারে ব্যবহৃত হয়। বাকি এটি এটি করতে সঠিক বিন্যাসে ইনপুট পাচ্ছে।


শেষ পরীক্ষার মামলায় ব্যর্থ :( tio.run/…
শেগি


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 বাইট ovs ধন্যবাদ।

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মন্দ ... তবে সম্ভবত আরও গোলাপী : P: P



2

জাভাস্ক্রিপ্ট (ES7), 68 67 বাইট

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


চমৎকার সমাধান! হতে পারে আপনি কয়েকটি বাইট সংরক্ষণ করার জন্য oপ্রথম বন্ধনীর ভিতরে অ্যাসাইনমেন্টটি স্থানান্তর করতে পারেন .pop()
লুক

@ লুক অ্যাসাইনমেন্টটি oটার্নারি অপারেটরের শর্ত হিসাবেও ব্যবহৃত হয়। যে স্কিম ভাঙ্গতে হবে।
আর্নৌল্ড

@Shaggy। ঠিক একই প্রথম আরনাউল্ডের উত্তর ছিল।

@ দি পাইরেট বে: আহ। এসই মোবাইলে তাই সম্পাদনা ইতিহাস দেখতে পারে না।
শেগি

2

পার্ল 6 ,67 66 বাইট

@ নয়েলহোফের জন্য 1 বাইট সংরক্ষণ করা হয়েছে।

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

এটি অনলাইন চেষ্টা করুন!

খুব অকল্পনীয় (এবং সম্ভবত খারাপ) সমাধান। জিপগুলি নিজের সাথে যুক্তিটি বিপরীত করে। ফলস্বরূপ তালিকাটি EVALস্ট্রিংয়ের ব্লকের সাথে ম্যাপ করা হয় a (operator) b। ফ্রি <+ * - div % **>ব্যবহার করে স্ট্রিংয়ের তালিকা থেকে অপারেটরটি বেছে নেওয়া হয় state( staticসি তে ভাবেন - মানটি ব্লকের কলগুলিতে জুড়ে থাকে) ভেরিয়েবল $। এটি প্রতিটি ব্লকের জন্য পৃথকভাবে তৈরি করা হয় এবং এটিতে সেট করা হয় 0 আপনি এটির সাথে নিজের পছন্দমতো কিছু করতে পারেন তবে আপনি কেবল এটি একবারে উল্লেখ করতে পারেন (প্রতিটি ঘটনাই $অন্য পরিবর্তনশীলকে বোঝায়, প্রকৃতপক্ষে)। তাই $++%6দ্বিতীয়, ... 5 6 ষ্ঠ, 0 7th ইত্যাদি সময় সময় সময় আসলে 0 প্রথম কল, 1 সময় নেই।

আমি প্রথমে একটি ছাড়া ছাড়া করার চেষ্টা করেছি EVAL। অপারেটররা আসলে কেবল সাব (= ফাংশন), তবে তাদের নামগুলি এতটাই অসম্পূর্ণ ( &infix:<+>এবং আরও কিছু) যে আমাকে সেই পদ্ধতিকে এড়িয়ে যেতে হয়েছিল।


map {EVAL ".[0] ... .[1]"},zip $_,.reverse1 বাইট সংক্ষিপ্ত।
nwellnhof

@ ননহ্নহোফ, ধন্যবাদ!
Ramillies

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

এটি অনলাইন চেষ্টা করুন!

@ নিমিকে ধন্যবাদ 12 বাইট সংরক্ষণ করা হয়েছে

এটি অর্জনের আরও অবশ্যই ভাল উপায় আছে।

সম্পাদনা 1. পূর্ণসংখ্যার জন্য স্থির ঘনিষ্ঠ; 2. অবশ্যই আরও ভাল উপায় আছে, নীচে মন্তব্য দেখুন: 95 91 বাইট

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

এটি অনলাইন চেষ্টা করুন!


zipWith3($)(cycle[(+),(*),(-),div,mod,(^)])<*>reverseএকটি সংক্ষিপ্ত, এখন আপনার নিজের সংস্করণ মুছে ফেলা।
এইচ.পি.উইজ

@ এইচ.পি.উইজ আমি এরকম কিছু খুঁজছিলাম কিন্তু আরও দেখার মতো সময় পাইনি। আপনি এটি মুছলেন কেন? আমি বিশ্বাস করি একই ভাষায় দুটি আলাদা সমাধান করা নিষিদ্ধ নয়, বিশেষত যখন একজনের চেয়ে অন্যের চেয়ে ভাল হয় ...
jferard

@ এইচ.পি.উইজ স্থির ঘাতক onent
jferard

hকল করার প্রয়োজন নেই o: o a bএবং এটি ছাড়া আপনি ইনলাইন করতে পারেন h( টিআইও )।
নিমি


1

জে, 44 42 বাইট

ক্রস করা হয়েছে 44, ইয়াডা ইয়াদা ...

-২ বাইটস @ কনরও ব্রায়েনকে ধন্যবাদ

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

এটি অনলাইন চেষ্টা করুন!

অনেকগুলি পেরেনস এবং সন্নিবেশ ... অবশ্যই এটি করার আরও ভাল উপায় আছে (সম্ভবত ইনফিক্সের চেয়ে সন্নিবেশ ব্যবহার করা উচিত?)

ব্যাখ্যা

_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

কিছু নোট:

জে এর পূর্ণসংখ্যা বিভাগ নেই, তাই আমরা %-ফ্লোয়ারের সাথে >.বিভাগটি রচনা করি। জে মোড ( |) আমরা যা প্রত্যাশা করতাম তার বিপরীত ক্রম করে, সুতরাং ~-আপনিটি ব্যবহার করে এর ক্রমটি উল্টাতে হবে।

যদিও আমরা ২ টির অন্তর /পেরিয়ে যাচ্ছি, ক্রিয়াপদগুলি dyadically ব্যবহার করার জন্য সন্নিবেশ করাতে হবে - যেহেতু \ইনফিক্স কীভাবে কাজ করে।


আমি কীভাবে সমস্ত ()এবং পুনরাবৃত্তি এড়ানো যায় /তা জানতে আগ্রহী ছিলাম - আমি এটি বের করতে সক্ষম হইনি ....
জোনা

@ জোনাহ, আমি সবচেয়ে ভালভাবে ভাবতে পারি যে /এটি একটি বিপরীত অ্যারের মতো (যেহেতু এটি পিছনের দিকে পরিচালিত হয় ...) এর মতো ক্রিয়া সহ (,+)`(,*)কিন্তু এটি তেমন কোনও
উপকার

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

1

এমএটিএল ,27 23 বাইট

-4 বাইটস @ লুইস মেন্ডোকে ধন্যবাদ

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

0

পার্ল 5 , 68 + 1 (-পি) = 69 বাইট

print$",eval'int 'x($i%6==3).$_.qw|+ ** % / - *|[$i--%6].$F[$i]for@F

এটি অনলাইন চেষ্টা করুন!

সংখ্যার স্থান পৃথকীকরণ তালিকা হিসাবে ইনপুট নেয়।


শেষ পরীক্ষার মামলায় ব্যর্থ :( tio.run/##K0gtyjH9/…
শেগি

আর না. :)
এক্সকালি

0

আর , 74 বাইট

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

এটি অনলাইন চেষ্টা করুন!

এটিই আমি নিয়ে এসেছি চূড়ান্ত উত্তর। এটি দৈর্ঘ্যের একটি তালিকা প্রদান করে length(l)যেখানে প্রতিটি উপাদানটি সম্পর্কিত উপাদানযুক্ত একটি তালিকা। কিন্ডা কৃপণ কিন্তু তারা সব আছে। যদি তা অগ্রহণযোগ্য হয়, তবে কোনওটি +3 বাইটের Mapসাথে প্রতিস্থাপন করা যেতে পারে mapply

যেহেতু আর অপারেটরগুলি সমস্ত ফাংশন (ইনফিক্স নোটেশনটি কেবল সিনট্যাকটিক চিনিযুক্ত), তাই আমি একটি তালিকা থেকে একটি নির্বাচন করার চেষ্টা করেছি; উদাহরণস্বরূপ, নীচে 94 বাইট সমাধান।

চেষ্টা করতে এবং লুপ থেকে মুক্তি পাওয়ার জন্য, আমি চেষ্টা করেছি sapply, তবে এটি কেবল একটি একক ফাংশন এবং ইনপুট তালিকা দিয়ে কাজ করে। তারপরে আমি মাল্টিভারিয়েট ফর্মটি মনে রাখলাম mapply, যা একটি n-aryক্রিয়াকলাপ FUNএবং nসফল যুক্তি গ্রহণ করে, FUNপ্রথম, দ্বিতীয়, ..., প্রতিটি যুক্তির উপাদানগুলির প্রয়োগ করে, প্রয়োজনে পুনর্ব্যবহার করা । এখানে একটি মোড়ক ফাংশনও রয়েছে mapply, Mapএটি "ফলাফলকে সহজ করার কোনও প্রচেষ্টা করে না" । এটি তিনটি বাইট সংক্ষিপ্ত হওয়ার কারণে এটি গল্ফ করার একটি ভাল সুযোগ opportunity

সুতরাং আমি একটি ট্রাইনারি ফাংশন সংজ্ঞায়িত করেছি (নীচে 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

Loops i0 থেকে length(l)-1, এ ধারাবাহিক উপাদান গ্রহণ oতালিকা এবং প্রয়োগের l[i]জন্য xএবং l[-i]জন্য y। (নেতিবাচক সূচকগুলি যদিও কাজ করে না, সুতরাং পরিবর্তে আমি বিয়োগ করিi তালিকাটির দৈর্ঘ্য থেকে করে সূচিটি গ্রহণ করি))

ফাংশনটির জন্য 107 বাইট, lপরামিতি বাক্সে যোগ করতে +1 বাইট ।


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
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.