44

গতবার যখন আমি এমন সহজ কিছু নিয়ে আসার চেষ্টা করলাম যা সদৃশ ছিল না, তবে এটি খুব শক্তভাবেই শেষ হয়েছিল ... সুতরাং আশা করি এবার নতুন কিছু চেষ্টা করার চেষ্টাও করবেন।

ইনপুট:

পূর্ণসংখ্যা / দশমিক সহ একটি অ্যারে / তালিকা। (অথবা একটি স্ট্রিং পূর্ণসংখ্যা / দশমিক সহ একটি অ্যারের প্রতিনিধিত্ব করে))

আউটপুট:

সংখ্যার মধ্য দিয়ে লুপ করুন এবং এই ক্রমে নিম্নলিখিত পাঁচটি গাণিতিক ক্রিয়াকলাপ প্রয়োগ করুন:

সংযোজন ( +);
বিয়োগ ( −);
গুণ ( *বা ×বা ·);
রিয়েল / ক্যালকুলেটর বিভাগ ( /বা ÷);
ক্ষয়ক্ষতি ( ^বা **)।

(দ্রষ্টব্য: প্রথম বন্ধনের মধ্যে চিহ্নগুলি কেবল ব্যাখ্যা হিসাবে যুক্ত করা হয়েছে your যদি আপনার প্রোগ্রামিং ভাষা উদাহরণগুলির চেয়ে গাণিতিক ক্রিয়াকলাপের জন্য সম্পূর্ণ আলাদা চিহ্ন ব্যবহার করে তবে অবশ্যই এটি সম্পূর্ণ গ্রহণযোগ্য))

আপনি তালিকার শেষে না পৌঁছানো অবিরত রাখুন এবং তারপরে যোগফলের ফলাফল দিন।

চ্যালেঞ্জ বিধি:

0 ( n ^ 0) দ্বারা ক্ষয়ক্ষতি 1 এর ফলে হওয়া উচিত (এটিও প্রযোজ্য 0 ^ 0 = 1)।
0 ( n / 0) দ্বারা বিভাগের জন্য কোনও পরীক্ষার কেস নেই , সুতরাং আপনাকে সেই প্রান্ত-কেস সম্পর্কে চিন্তা করতে হবে না।
অ্যারেটিতে যদি কেবল একটি একক সংখ্যা থাকে তবে আমরা ফলাফল হিসাবে ফিরে আসি।

সাধারণ নিয়ম:

এটি কোড-গল্ফ , তাই বাইট জেতে সংক্ষিপ্ত উত্তর।
কোড-গল্ফ ভাষাগুলি আপনাকে নন-কোডগলফিং ভাষার সাথে উত্তর পোস্ট করতে নিরুৎসাহিত করবেন না। 'যে কোনও' প্রোগ্রামিং ভাষার পক্ষে যতটা সম্ভব সংক্ষিপ্ত উত্তর নিয়ে আসার চেষ্টা করুন।
স্ট্যান্ডার্ড নিয়মগুলি আপনার উত্তরের জন্য প্রযোজ্য , সুতরাং আপনাকে সঠিক পরামিতিগুলি, সম্পূর্ণ প্রোগ্রামগুলির সাথে STDIN / STDOUT, ফাংশন / পদ্ধতি ব্যবহারের অনুমতি দেওয়া হবে। আপনার কল
ডিফল্ট লুফোলগুলি নিষিদ্ধ।
যদি সম্ভব হয় তবে আপনার কোডের জন্য একটি পরীক্ষার সাথে একটি লিঙ্ক যুক্ত করুন।

পরীক্ষার কেস:

[1,2,3,4,5] -> 0
-> 1 + 2 = 3
  -> 3 - 3 = 0
    -> 0 * 4 = 0
      -> 0 / 5 = 0 

[5,12,23,2,4,4,2,6,7] -> 539
-> 5 + 12 = 17
  -> 17 - 23 = -6
    -> -6 * 2 = -12
      -> -12 / 4 = -3
        -> -3 ^ 4 = 81
          -> 81 + 2 = 83
            -> 83 - 6 = 77
              -> 77 * 7 -> 539

[-8,50,3,3,-123,4,17,99,13] -> -1055.356...
-> -8 + 50 = 42
  -> 42 - 3 = 39
    -> 39 * 3 = 117
      -> 117 / -123 = -0.9512...
        -> -0.9512... ^ 4 = 0.818...
          -> 0.818... + 17 = 17.818...
            -> 17.818... - 99 -> -81.181...
              -> -81.181... * 13 = -1055.356...

[2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2] -> 256
-> 2 + 2 = 4
  -> 4 - 2 = 2
    -> 2 * 2 = 4
      -> 4 / 2 = 2
        -> 2 ^ 2 = 4
          -> 4 + 2 = 6
            -> 6 - 2 = 4
              -> 4 * 2 = 8
                -> 8 / 2 = 4
                  -> 4 ^ 2 = 16
                    -> 16 + 2 = 18
                      -> 18 - 2 = 16
                        -> 16 * 2 = 32
                          -> 32 / 2 = 16
                            -> 16 ^ 2 = 256

[1,0,1,0,1,0] -> 1
-> 1 + 0 = 1
  -> 1 - 1 = 0
    -> 0 * 0 = 0
      -> 0 / 1 = 0
        -> 0 ^ 0 = 1

[-9,-8,-1] -> -16
  -> -9 + -8 = -17
    -> -17 - -1 = -16

[0,-3] -> -3
  -> 0 + -3 = -3

[-99] -> -99

— কেভিন ক্রুইজসেন
সূত্র

পূর্ণসংখ্যা বিভাগ নয়?

— ফাঁস নুন

@ ল্যাকিয়ুন নং। সম্ভবত আমার বিভাগের কারণে পূর্ণসংখ্যার পরিবর্তে দশমিকের সাথে একটি তালিকাতে ইনপুটটি পরিবর্তন করা উচিত (এবং টেস্ট কেস 3)?

— কেভিন ক্রুইজসেন

এটি কি স্যান্ডবক্সে ছিল?

— বালিন্ট

9

গণিতে দুটি বিবাদযুক্ত "বিধি" রয়েছে: n ^ 0 = 1তবে 0 ^ n = 0। n != 0উভয় নিয়মের জন্য সেট করে দ্বন্দ্ব সমাধান করা হয় , তবে তারপরে এটি অপরিবর্তিত থাকে 0 ^ 0। যাইহোক, অনেকগুলি বিষয় রয়েছে যা 0 ^ 0সংজ্ঞায়িত হলে গণিতে খুব ভালভাবে পড়ে 1। কিছু বিশদ জন্য উইকিপিডিয়া দেখুন ।

— মেগো

1

@ বুলেটিন্ট বিধিগুলিতে বলা হয়েছে যে শূন্য দ্বারা বিভাজন সহ কোনও বৈধ ইনপুট কখনও হবে না। আপনাকে এজ প্রান্তটি নিয়ে চিন্তা করতে হবে না।

— মেগো

7

জেলি , 13 বাইট

“+_×÷*”ṁṖ⁸żFV

এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

কিভাবে এটা কাজ করে

“+_×÷*”ṁṖ⁸żFV  Main link. Argument: A (list of integers)

“+_×÷*”        Yield the list of operations as a string.
        Ṗ      Yield A popped, i.e., with its last element removed.
       ṁ       Mold; reshape the string as popped A.
               This repeats the characters of the string until it contains
               length(A)-1 characters.
         ⁸ż    Zipwith; pairs the integers of A with the corresponding characters.
           F   Flatten the result.
            V  Eval the resulting Jelly code.
               Jelly always evaluates left-to-right (with blatant disregard towards
               the order of operations), so this returns the desired result.

— ডেনিস
সূত্র

ভাল, পাইকের তুলনায় এটি 8 টি কম বাইট-কাউন্ট , যা বর্তমানে নেতৃত্বে ছিল।

— কেভিন ক্রুইজসেন

3

কেউ ডেনিসকে ছাড়িয়ে যায় না। কখনও।

— নীল

1

কেবল একটি প্রশ্ন: এটি কি সমস্ত অ-অসি চরিত্রের সাথে 13 বাইট হিসাবে গণনা করা হয় ?

— জাভেয়ের ডুরি

3

নিখুঁত শিরোনামের বাইটস লিঙ্কটি জেলির নিজস্ব কোড পৃষ্ঠাতে নিয়ে যায়, যা 256 টি অক্ষর এনকোড করে জেলি প্রতিটি একক বাইট হিসাবে বোঝে।

— ডেনিস

@ ডেনিস নির্ভুলতার জন্য আপনাকে ধন্যবাদ!

— জাভিয়ার ডুরি

19

জাভাস্ক্রিপ্ট ES7 49 বাইট

a=>a.reduce((c,d,e)=>[c**d,c+d,c-d,c*d,c/d][e%5])

ডম হেস্টিংসের 9 টি বাইট ধন্যবাদ সংরক্ষণ করা হয়েছে, লিকি নুনকে আরও 6 টি ধন্যবাদ বাঁচিয়েছে

নতুন ক্ষতিকারক অপারেটর ব্যবহার করে।

— Bálint
সূত্র

@LakyNun- এ কি কেবল উত্পাদন করা হবে না Infinity, ত্রুটি নয়?

— ডম হেস্টিংস

— ইভলটি

@ আপগোট এটি প্রথমে ইওল ব্যবহার করেছিল, তারপরে লিকি নুন আমাকে দেখিয়েছিলেন, এটি ভাল করাই ভালো

— বুলিন্ট

@ বুলিন্ট আপনি কি অনেকগুলি কমা ব্যবহার করেছেন?

— আর

1

@ EᴀsᴛᴇʀʟʏIʀᴋ অ-নেটিভ স্পিকার। বুলিন্ট প্রায়শই এটি করেন। ইংলিশ ব্যাকরণটি সময়ের সেরা সময়ে নির্বোধ।

— wizzwizz4

11

হাস্কেল, 76 65 64 62 বাইট

আরও দুটি বাইট অপসারণ করার জন্য @ ড্যামিয়েনকে ধন্যবাদ =)

f(u:v)=foldl(\x(f,y)->f x y)u(zip(v>>[(+),(-),(*),(/),(**)])v)

>>এখানে যা কেবলমাত্র তালিকাটিকে [(+),...]নিজের length vসময়ে সংযোজন করে এটি ব্যবহার করে । বাকিগুলি এখনও পুরানো সংস্করণগুলির মতো একইভাবে কাজ করে।

পুরানো সংস্করণ:

এই সমাধানগুলি অসীম তালিকাগুলি ব্যবহার করে, যেমন cycle[...]প্রদত্ত তালিকার অসীম পুনরাবৃত্তি করে। তারপরে এটি মূলত zipসংখ্যার তালিকার সাথে এড হয়ে যায়, এবং আমরা কেবল একটি ল্যাম্বডার মাধ্যমে জিপড তালিকাটি fold( অন্য ভাষাগুলিতে হ্রাস করতে পারি ) যা সঞ্চালক / বর্তমান তালিকার উপাদানটিতে অপারেটরদের প্রয়োগ করে।

f(u:v)=foldl(\x(f,y)->f x y)u(zip(cycle[(+),(-),(*),(/),(**)])v)

f(u:v)=foldl(\x(y,f)->f x y)u(zip v(cycle[(+),(-),(*),(/),(**)]))

f l=foldl(\x(y,f)->f x y)(head l)(zip(drop 1l)(cycle[(+),(-),(*),(/),(**)]))

— flawr
সূত্র

আপনি চক্রটি এর দ্বারা প্রতিস্থাপন করতে পারেন: v >>

— ড্যামিয়েন

@ দামিয়ান আপনাকে অনেক ধন্যবাদ!

— flawr

এইচএম foldl(&)u$zipWith(&)v(flip<$>v>>[…]),?

— বার্গি

@Bergi আমি ভাল পড়তে পারে না কি এটা আর কাজ করা হয় =) যাই হোক, আমরা একটি প্রয়োজন importজন্য &, যাতে আর আবার হতে পারে, কিন্তু যাহাই হউক না কেন ধন্যবাদ!

— flawr

@ ফ্লোয়ার: আসলে আমার ধারণাটি লেজারমার্কের উত্তর হিসাবে পোস্টের মতো ঠিক একই রকম ছিল, আমি কেবল এটি পড়িনি। আপনার লামদাটিকে এমন কিছু দিয়ে সহজ করার চেষ্টা করার সময় আমি এটি পেয়েছিলাম uncurry। কার্যকর হয়নি, তবে আমি লক্ষ্য করেছি আপনার $প্রথম বন্ধনী ব্যবহারের পরিবর্তে অন্য একটি বাইট সংরক্ষণ করতে সক্ষম হওয়া উচিত ।

— বার্গি

8

পাইকে, 22 21 বাইট

lt5L%"+-*/^"L@\RJQ_XE

এখানে চেষ্টা করুন!

lt5L%                 -    map(len(input)-1, %5)
     "+-*/^"L@        -   map(^, "+-*/^"[<])
              \RJ     -  "R".join(^)
                    E - pyke_eval(^, V)
                 Q_X  -  splat(reversed(input))

— নীল
সূত্র

7

হাস্কেল, 61 বাইট

foldl(flip id)0.zipWith flip((+):cycle[(+),(-),(*),(/),(**)])

[যুক্ত 1 যোগ করুন, 2 যোগ করুন, 3 বিয়োগ করুন, ...] হিসাবে একটি তালিকায় ধারাবাহিক রূপান্তরগুলি তৈরি করুন, কারণ আমরা ভাঁজটিতে 0 দিয়ে শুরু করি। এরপরে, আমরা যা করি তালিকার অ্যাপ্লিকেশন ভাঁজ বা ফোল্ডেল (ফ্লিপ আইডি), যা সিরিজটিতে হোমোমর্ফিজমের একটি তালিকা প্রয়োগ করে do এটি শূন্য দিয়ে শুরু হয়, প্রাথমিক মান যুক্ত করে, তারপরে একটি চূড়ান্ত ফলাফল পেতে উপরের সমস্ত গণিত রূপান্তরগুলি করে।

মনে রাখবেন (ফ্লিপ আইডি) (\ x y-> yx) এর মতো, কেবল খাটো।

নমুনা ব্যবহার:

f = foldl(flip id)0.zipWith flip((+):cycle[(+),(-),(*),(/),(**)])
f [1,2,3,4,5] -- Is 0.0

— Lazersmoke
সূত্র

পরিবর্তে flip id, আপনি কেবল ব্যবহার করতে পারেন &। বা flip($)। বাহ, আমি কখনই বুঝতে পারি নি($) = id

— বার্গি

1

@ বার্গি: &এটি সংজ্ঞায়িত হয়েছে Data.Function, সুতরাং আপনারও এটির দরকার import। হতে পারে কোনও অনলাইন অনুবাদক ডিফল্টরূপে এটি আমদানি করে তবে তার পরে আপনি কোনটি ব্যবহার করবেন তা নির্দিষ্ট করতে হবে।

— নিমি

7

টিএসকিউএল 116 115 88 বাইট

রস প্রেসার পরামর্শের জন্য ধন্যবাদ আমি এটিকে 88 টি চরিত্রের মধ্যে গল্ফ করতে সক্ষম হয়েছি

-- In Try-it code, this must be DECLARE @y TABLE 
CREATE TABLE T(a real, i int identity)
INSERT T values(5),(12),(23),(2),(4),(4),(2),(6),(7)

DECLARE @ REAL SELECT @=CHOOSE(i%5+1,@/a,ISNULL(POWER(@,a),a),@+a,@-a,@*a)FROM T
PRINT @

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

— t-clausen.dk
সূত্র

1

1 কম বাইট: ইনপুট টেবিলটিকে @ y এর পরিবর্তে টি নামকরণ করা প্রয়োজন। পিএল / এসকিউএল সমাধানটিতে এটি ছিল, সুতরাং কেন টিএসকিউএল নয়।

— রস প্রেসার

@ রসপ্রেসার অবশ্যই হ্যাঁ আমি কীভাবে মিস করেছি এটি পরীক্ষার লিঙ্কে সম্ভব নয়, টেবিলগুলি তৈরি করার অনুমতি নেই এবং এটি কোনও ডাটাবেজে প্রথমবার সঠিকভাবে চলবে। কিন্তু কোনও চরিত্র যখন গল্ফ করা যায় তখন কী হয়। আপনার ইঙ্গিতটির জন্য ধন্যবাদ, আপনার উন্নতি যুক্ত করা হয়েছে

— t-clausen.dk

আরও 12 টি বাইট গল্ফ করা হয়েছে: নেস্টেড আইআইএফের পরিবর্তে নির্বাচন করুন, আই = 1 কেসের জন্য একটি আইআইএফ রেখে দিন। আপনার অনুমতি নিয়ে, আমি উত্তরটি সম্পাদনা করব।

— রস প্রেসার

উত্তর সম্পাদিত। এখানে চেষ্টা করে দেখুন লিঙ্কটি - আমি বেনামে রয়েছি সুতরাং এর কোনও নাম নেই: ডেটা.স্ট্যাকেক্সেঞ্জ

— রস প্রেসার

1

@RossPresser আমি পছন্দ করতাম না। আপনার পরামর্শ অন্তর্ভুক্ত করুন এবং এটি আরও কিছুটা গল্ফ করেছেন

— t-clausen.dk

6

পাইথ, 27 26 25 বাইট

.v+>tlQ*lQ"^c*-+":jdQ\-\_

পরীক্ষা স্যুট.

পাইথ প্রিফিক্স স্বরলিপি ব্যবহার করে: 1+2এটি +1 2(পৃথক সংখ্যার জন্য পৃথক স্থান প্রয়োজন) হিসাবে লেখা হয় ।

সুতরাং, প্রথম টেস্টকেসটির জন্য, প্রকাশটি হবে (((1+2)-3)*4)/5, যা উপসর্গের নোটে লেখা থাকবে /*-+ 1 2 3 4 5।

পাইথের cপরিবর্তে ভাসা বিভাগ রয়েছে /, তাই এটি হয়ে যায় c*-+ 1 2 3 4 5।

এছাড়াও, পাইথে, পরিবর্তে -100লেখা হয় _100।

অতএব, তৃতীয় টেস্টে মামলা, যার জন্য ((((((((-8+50)-3)*3)/-123)^4)+17)-99)*13), এটা হয়ে: *-+^c*-+ _8 50 3 3 _123 4 17 99 13।

.v+>tlQ*lQ"^c*-+":jdQ\-\_
                  jdQ       Join input by space.
                 :   \-\_   Replace "-" with "_".
   >tlQ*lQ"^c*-+"           Generate the string "...^c*-+" of suitable length.
  +                         Join the two strings above.
.v                          Evaluate as a Pyth expression.

ইতিহাস

33 বাইট: v:P+*lQ$ssV+R$Q*"+-*/p"lQ\p"**"
27 বাইট: .vs+_XUtQUQ"+-*c^"m:+;d\-\_
26 বাইট: .vs+_XUtQUQ"+-*c^":jdQ\-\_

— ফুটো নুন
সূত্র

আপনি দ্রুত! দেখে মনে হচ্ছে আমি আরও সহজ চ্যালেঞ্জ তৈরি করতে সফল হয়েছি। বা আপনি ঠিক যে ভাল। ;)

— কেভিন ক্রুইজসেন

1

কারণ এটি এর সাথে সমান ।

— ফাঁস নুন

2

24 বাইট

— মালটিসেন

6

আসলে, 23 বাইট

;l"+-*/ⁿ"*@R':j':+'?o+ƒ

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

প্রকৃতপক্ষে গণিতের জন্য পোস্টফিক্স স্বরলিপি ব্যবহার করে এবং অপারেটররা কেবল দুটি যুক্তি (যেমন সংযোজন, বিয়োগ, গুণ, বিভাগ এবং ক্ষতিকারক হিসাবে অপারেটর) গ্রহণ করে যখন স্ট্যাকের মধ্যে কেবল একটি উপাদান থাকে তখন কিছুই করেন না। সুতরাং, ইনপুটটিকে প্রকৃতপক্ষে কোডে রূপান্তর করা ইনপুটকে উল্টানো, এটি সংখ্যার আকারে ফর্ম্যাট করা এবং ক্রিয়াকলাপ সংযোজন করার মতোই সহজ is তারপরে, ফলাফল কোড কার্যকর করা যাবে, কাঙ্ক্ষিত আউটপুট দেয়।

ব্যাখ্যা:

;l"+-*/ⁿ"*@R':j':+'?o+ƒ
;l"+-*/ⁿ"*               repeat the operations a number of times equal to the length of the input
                            (since extraneous operations will be NOPs, there's no harm in overshooting)
          @R             reverse the input
            ':j          join on ":" (make a string, inserting ":" between every pair of elements in the list)
               ':+       prepend a ":" (for the first numeric literal)
                  '?o    append a "?"
                           (this keeps the poor numeric parsing from trying to gobble up the first + as part of the numeric literal, since ? isn't interpreted as part of the literal, and is a NOP)
                     +   append the operations string
                      ƒ  cast as a function and call it

ইনপুট জন্য অনুবাদকৃত কোডের উদাহরণ 1,2,3,4,5:

:5:4:3:2:1?+-*/ⁿ+-*/ⁿ+-*/ⁿ+-*/ⁿ+-*/ⁿ

— ঐ মেগো
সূত্র

3

ভাষার নামটি কীভাবে বাইট

— গণনাটির

3

s/Actually uses postfix notation/Actually actually uses postfix notation/

— লিকি নুন

6

জুলিয়া, 53 50 বাইট

!x=(i=0;foldl((a,b)->(+,-,*,/,^)[i=i%5+1](a,b),x))

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

— ডেনিস
সূত্র

5

জে, 40 বাইট

^~`(%~)`*`(-~)`+/@(|.@,7#:~#&2)(5-5|4+#)

এই অপারেটরগুলির পরিচয় মান সহ প্যাডের চেয়ে 5 টি অপারেটরের একাধিক ব্যবহারের জন্য প্রয়োজনীয় মানের সংখ্যা সন্ধান করে। ক্রমানুসারে, +0 হয়, -0 হয়, *1 হয়, %1 হয় এবং ^1 হয় যা কিছুটা মান হতে পারে 00111বা বেস 10 এ 7 তারপরে অপারেটরগুলির মাধ্যমে সাইকেল চালানোর সময় সেই তালিকায় কাজ করে।

ব্যবহার

   f =: ^~`(%~)`*`(-~)`+/@(|.@,7#:~#&2)(5-5|4+#)
   f 1 2 3 4 5
0
   f 5 12 23 2 4 4 2 6 7
539
   f _8 50 3 3 _123 4 17 99 13
_1055.36
   f 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
256
   f 1 0 1 0 1 0
1
   f _9 _8 _1
_16
   f 0 _3
_3
   f _99
_99

ব্যাখ্যা

^~`(%~)`*`(-~)`+/@(|.@,7#:~#&2)(5-5|4+#) Input: A
                                      #  Get length of A
                                    4+   Add four to it
                                  5|     Take it mod 5
                                5-       Find 5 minus its value, call it x
                           #&2           Create x copies of 2
                       7#:~              Convert 7 to base 2 and take the last x digits
                      ,                  Append those x digits to the end of A
                   |.@                   Reverse it, call it A'
^~                                       Power, reversed operators
    %~                                   Division, reversed operators
       *                                 Multiplication
         -~                              Subtraction, reversed operators
            +                            Addition
             /@                          Insert the previous operations, separated by `,
                                         into A' in order and cycle until the end
                                         Then evaluate the equation from right-to-left
                                         and return

— মাইল
সূত্র

5

পাইথন 2, 81 67 64 বাইট

i=10
for n in input():exec'r%s=n'%'*+-*/*'[i::5];i=-~i%5
print r

ইনপুটটি ভাসমানগুলির একটি অ্যারে। আইডিয়নে এটি পরীক্ষা করুন ।

কিভাবে এটা কাজ করে

'*+-*/*'[i::5]নির্বাচন স্ট্রিং প্রতিটি পঞ্চম অক্ষর, সূচিতে এক সঙ্গে শুরু আমি , তাই এই উৎপাদনের **যদি আমি 0 = , +যদি আমি 1 = , -যদি আমি 2 = , *যদি i = 3 এবং /যদি i = 4 । যেহেতু স্ট্রিংটির দৈর্ঘ্য 6 রয়েছে , তাই i> 5 হলে এক্সপ্রেশনটি একটি খালি স্ট্রিং দেবে ।

আমরা পরিবর্তনশীল আরম্ভ আমি করতে 10 । ইনপুট অ্যারেতে প্রতিটি সংখ্যা এন এর জন্য, আমরা স্ট্রিংটি তৈরি করি r<op>=nযা কার্যকর execকরে।

প্রাথমিকভাবে, i = 10 , তাই <op>খালি স্ট্রিং, এবং এটা সূচনা R সঙ্গে r+=n। প্রতিটি পদক্ষেপের পরে, আমরা 5 দিয়ে মডুলো বৃদ্ধি করি , সুতরাং পরবর্তী পদক্ষেপটি সঠিক অপারেটরটি পুনরুদ্ধার করবে।i=-~i%5

সমস্ত ইনপুট নম্বরগুলি প্রক্রিয়া করা হয়ে গেলে এবং আমরা r প্রিন্ট করি যা পছন্দসই আউটপুট ধারণ করে।

— ডেনিস
সূত্র

5

মতলব - 95 91 85 বাইট / অক্টেভ - 81 বাইট

ইনপুট এ জাতীয় আকারে a = ['1' '2' '3' '4' '5'];:, আমি আশা করি এটি "সংখ্যার / দশমিকের সাহায্যে একটি অ্যারের প্রতিনিধিত্ব করে স্ট্রিং" দ্বারা আচ্ছাদিত হবে, অন্যথায় অতিরিক্ত 2 টি সংখ্যা 2 রয়েছে।

প্রতিটি মধ্যবর্তী ফলাফল কনসোলে মুদ্রিত হয় কারণ এটি আমার কিছু সেমিকোলন সংরক্ষণ করে। a(1)কার্যকর করা হয় তাই এর মানটি এতে সংরক্ষণ করা হয় ans। অবশ্যই ansকোড ব্যবহার করা খারাপ অভ্যাস।

b='+-*/^'
a(1)
for i=2:length(a)
  ['(',ans,')',b(mod(i-2,5)+1),a(i)]
end
eval(ans)

অক্টেভ সালে '+-*/^'(mod(i+2,5)+1)এছাড়াও কাজ করে, যা অন্য 4 বাইট, ধন্যবাদ আদম এবং লুইস Mendo সংরক্ষণ:

a(1)
for i=2:length(a)
  strcat('(',ans,')','+-*/^'(mod(i-2,5)+1),a(i))
end
eval(ans)

পরিবর্তণের:

যেখানে সম্ভব স্থানগুলি সরানো হয়েছে
অক্টাভা সমাধান যোগ করা হয়েছে
[] এর সাথে স্ট্রিকাট () প্রতিস্থাপন করা হয়েছে

— লুকাস কে।
সূত্র

হাই, পিপিসিজিতে আপনাকে স্বাগতম! ইনপুটটি ঠিক সেইরকম, কারণ ইনপুটটি কী তা সহজেই পার্থক্যযোগ্য। হুম, আমি মতলব কখনও ব্যবহৃত, তাই হয়তো, আমি আহাম্মক জিনিষ এখানে বলছি, কিন্তু না পারেন, b = '+-*/^'করতে golfed করা b='+-*/^'এবং for i = 2:length(a)করতে for i=2:length(a)(ব্যবধান সরানোর)? এছাড়াও, সম্ভবত ম্যাটল্যাবে গল্ফ করার টিপস আপনার জন্য আকর্ষণীয় হতে পারে। :)

— কেভিন ক্রুইজসেন

কি '+-*/^'(mod(i+2,5)+1)বৈধ?

— অ্যাডম

@ অ্যাডেম না, তবে এটি সম্ভবত অক্টোবায়

— লুইস মেন্ডো

@ অ্যাডাম: এটি অক্টাভে কাজ করে, আমি এটি যুক্ত করেছি।

— লুকাশ কে।

4

গণিত, 67 67 65 বাইট

Fold[{+##,#-#2,#2#,#/#2,If[#2==0,1,#^#2]}[[i++~Mod~5+1]]&,i=0;#]&

সূচকটি ধারণ করে Foldএকটি ভেরিয়েবল সহ সহজ i।

— LegionMammal978
সূত্র

একটি বাইট দ্বারা সংরক্ষণ করা যাবে +##পরিবর্তে#+#2

— LLlAMnYP

4

সিজেম, 18 বাইট

q~{"+-*/#"W):W=~}*

ইনপুটটি ভাসমানগুলির একটি অ্যারে। এটি অনলাইন চেষ্টা করুন!

কিভাবে এটা কাজ করে

q~                  Read and evaluate all input.
  {             }*  Reduce:
   "+-*/#"            Push the string of operators.
          W           Push W (initially -1).
           ):W        Increment and save in W.
              =       Retrieve the character at that index.
               ~      Evaluate.

— ডেনিস
সূত্র

4

আর , 87 78 70 বাইট

i=0
Reduce(function(a,j)get(substr("+-*/^",i<<-i%%5+1,i))(a,j),scan())

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

— JayCe
সূত্র

এক পর্যায়ে আমাকে কীভাবে ব্যবহার করতে হবে তা শিখতে হবে do.call... আমি না হওয়া পর্যন্ত সম্ভবত নিজেকে আর আর প্রোগ্রামার হিসাবে বিবেচনা করা উচিত নয়!

— জিউসেপে

1

@ জিডেস্পের Advanced Rহ্যাডলি উইকাম একটি দুর্দান্ত সমুদ্র সৈকত পঠন করেছেন :)

— জেইসি

@ জিউস্পেপকে নির্দেশ করার জন্য ধন্যবাদ do.call- আমাকে বুঝতে পেরেছি যে আমি সন্ধান করছি get।

— জেসি

3

হাস্কেল - 74

f(x:xs)=foldl(\x(o,y)->o x y)x(zip(cycle[(+),(-),(*),(/),flip(^).floor])xs)

পরীক্ষার কেস:

λ> f[1,2,3,4,5] -> 0.0
λ> f[5,12,23,2,4,4,2,6,7] -> 539.0
λ> f[-8,50,3,3,-123,4,17,99,13] -> -1055.356943846277
λ> f [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2] -> 256.0

এটি সম্ভবত সংক্ষিপ্ত হতে পারে; অসীম তালিকা এবং উচ্চতর আদেশ ক্রিয়াকলাপগুলির জন্য হাস্কেলের সমর্থন সরাসরি সমাধানটিকে বেশ মনোরম করে তোলে। ^ :: Double -> Double -> Doubleগল্ফ করার জন্য একটি সংস্করণ ভাল লাগবে, তবে আমি এটির সন্ধান করতে পারি নি। ধন্যবাদ, আমার একটি পূর্ণ ল্যাম্বডা দরকার ছিল না, তাই নির্বিকার শৈলীর কয়েকটি বাইট বন্ধ করে দেওয়া হয়েছিল।

— সি কুইলি
সূত্র

2

আপনি একটি একক পূর্বে লিখুন করতে (+)অপারেটরদের লিস্টে শুরু foldlসঙ্গে 0সম্পূর্ণরূপে pointfree যান এবং ফাংশনের নাম এবং পরামিতি সংরক্ষণ করতে: foldl(\x(o,y)->o x y)0.zip((+):cycle[(+),(-),(*),(/),(**)])।

— নিমি

3

পাওয়ারশেল ভি 2 +, 124 বাইট

param($n)$o=$n[0];if($y=$n.count-1){1..$y|%{$o=if(($x=$i++%5)-4){"$o"+'+-*/'[$x]+$n[$_]|iex}else{[math]::pow($o,$n[$_])}}}$o

দীর্ঘ কারণ পাওয়ারশেলের একটি ^বা **অপারেটর নেই, তাই আমাদের একটি পৃথক কেসের জন্য অ্যাকাউন্ট করতে হবে এবং একটি নেট কল ব্যবহার করতে হবে।

$nঅ্যারে হিসাবে ইনপুট নেয় , আমাদের আউটপুটটিকে $oপ্রথম অঙ্ক হিসাবে সেট করে । তারপরে আমরা .countঅ্যারের পরীক্ষা করে নিই এবং যতক্ষণ না এটি একটির চেয়ে বড় হয় আমরা প্রবেশ করি if। অন্যথায়, আমরা এড়িয়ে চলি if।

ifঅ্যারের মধ্য দিয়ে লুপের ভিতরে 1..$y|%{...}এবং প্রতিটি পুনরাবৃত্তি আমরা আবার $oনতুন মানতে সেট করি , অন্য if/elseবিবৃতিটির ফলাফল । যতক্ষণ $i++না আমাদের কাউন্টারটি মডুলো -5 4 এর সমান নয় (যেমন, আমরা ^অপারেটরে নেই), আমরা কেবল $oএটিকে উপযুক্ত চিহ্ন '+-*/'[$x]এবং ইনপুট অ্যারেতে পরবর্তী নম্বর দিয়ে সংযুক্ত করি $n[$_]। আমরা এটির পাইপ iex(এর জন্য Invoke-Expressionএবং তার অনুরূপ eval), এবং এটি এতে পুনরায় সংরক্ষণ করা হবে $o। আমরা হন, তাহলে ^অপারেটর, আমরা আছি else, তাই আমরা একটি চালানো [math]::Pow()কল, এবং যে ফলাফলের মধ্যে পুনরায় সংরক্ষণ ফিরে পায় $o।

উভয় ক্ষেত্রেই, আমরা কেবল $oপাইপলাইনে আউটপুট এবং আউটপুট অন্তর্ভুক্ত সহ প্রস্থান করি।

— AdmBorkBork
সূত্র

3

মরিচা, 123 , 117 বাইট

আসল উত্তর:

fn a(v:&[f32])->f32{v.iter().skip(1).enumerate().fold(v[0],|s,(i,&x)|match i%5{0=>s+x,1=>s-x,2=>s*x,3=>s/x,_=>s.powf(x)})}

বোকা দীর্ঘ পদ্ধতির নাম h আহ আরও ভাল

fn f(v:&[f32])->f32{v[1..].iter().zip(0..).fold(v[0],|s,(&x,i)|match i%5{0=>s+x,1=>s-x,2=>s*x,3=>s/x,_=>s.powf(x)})}

ungolfed

fn f(values : &[f32]) -> f32 {
    values[1..].iter().zip(0..)
    .fold(values[0], |state,(&x,i)|
        match i%5 {
            0=>state+x,
            1=>state-x,
            2=>state*x,
            3=>state/x,
            _=>state.powf(x)
        }
    )
}

— raggy
সূত্র

3

পার্ল 6 , 70 68 65 62 বাইট

{$/=[(|(&[+],&[-],&[*],&[/],&[**])xx*)];.reduce: {$/.shift.($^a,$^b)}}
{(@_ Z |(&[+],&[-],&[*],&[/],&[**])xx*).flat.reduce: {&^b($^a,$^c)}}
{(@_ Z |(*+*,*-*,&[*],*/*,&[**])xx*).flat.reduce: {&^b($^a,$^c)}}
{reduce {&^b($^a,$^c)},flat @_ Z |(*+*,*-*,&[*],*/*,&[**])xx*}

ব্যাখ্যা:

-> *@_ {
  reduce
    -> $a, &b, $c { b($a,$c) },

    flat       # flatten list produced from zip
      zip
        @_,    # input

        slip(  # causes the list of operators to flatten into the xx list

          # list of 5 infix operators
          &infix:<+>, &infix:<->, &infix:<*>, &infix:</>, &infix:<**>

        ) xx * # repeat the list of operators infinitely
}

টেকনিক্যালি * + *হ'ল ল্যাম্বদা, তবে কার্যকরভাবে একই রকম যে সাব্রুটাইনগুলির সংস্থার &[+]জন্য সংক্ষিপ্ত যা &infix:<+>ইনফিক্স সংখ্যাসূচক সংযোজন পরিচালনা করে।
আমি এটিকে লিখার উপায় হিসাবে গুণ বা ক্ষয়ক্ষতির জন্য ব্যবহার করি নি কমপক্ষে যতটা আমার আছে ( *×*বা * * *এবং * ** *)

টেস্ট:

তে এটি পরীক্ষা করুন ideone.com
(তারা একটি আপগ্রেড পর Rakudo সংস্করণ যা এক বছর থেকে নয় এবং অফিসিয়াল রিলিজ করার পূর্বে একটি অর্ধ পার্ল 6 spectests )

#! /usr/bin/env perl6

use v6.c;
use Test;

my @tests = (
  [1,2,3,4,5] => 0,
  [5,12,23,2,4,4,2,6,7] => 539,
  [-8,50,3,3,-123,4,17,99,13] => -1055.35694385, # -2982186493/2825761
  [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2] => 256,
  [1,0,1,0,1,0] => 1,
  [-9,-8,-1] => -16,
  [0,-3] => -3,
  [-99] => -99,
);

plan +@tests;

my &code = {reduce {&^b($^a,$^c)},flat @_ Z |(*+*,*-*,&[*],&[/],&[**])xx*}

for @tests -> $_ ( :key(@input), :value($expected) ) {
  is code(@input), $expected, .gist
}

1..8
ok 1 - [1 2 3 4 5] => 0
ok 2 - [5 12 23 2 4 4 2 6 7] => 539
ok 3 - [-8 50 3 3 -123 4 17 99 13] => -1055.35694385
ok 4 - [2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2] => 256
ok 5 - [1 0 1 0 1 0] => 1
ok 6 - [-9 -8 -1] => -16
ok 7 - [0 -3] => -3
ok 8 - [-99] => -99

— ব্র্যাড গিলবার্ট বি 2 গিলস
সূত্র

51 বাইট

— জো কিং

3

পাইথন 3, 88 93 বাইট

f=lambda x:eval('('*(len(x)-1)+'){}'.join(map(str,x)).format(*['+','-','*','/','**']*len(x)))

এটি খুব খাটো হয়ে শুরু হয়েছিল তবে তারপরে অপারেটর অগ্রাধিকারটি আমাকে পরাজিত করে এবং আমাকে প্রচুর বন্ধনী অন্তর্ভুক্ত করতে হয়েছিল ...

— MSeifert
সূত্র

3

ওরাকল পিএল / এসকিউএল, 275 254 বাইট

declare r number;begin for x in (select n,mod(rownum,5)r from t) loop if r is null then r:=x.n;elsif x.r=2then r:=r+x.n;elsif x.r=3then r:=r-x.n;elsif x.r=4then r:=r*x.n;elsif x.r=0then r:=r/x.n;else r:=r**x.n;end if;end loop;DBMS_OUTPUT.PUT_LINE(r);end;

প্রকারের Tকলামের সাথে ডাকা একটি টেবিলে অবশ্যই ডেটা .োকাতে হবেNNUMBER

ব্যবহার:

drop table t;
create table t (n number);
insert into t values (-8);
insert into t values (50);
insert into t values (3);
insert into t values (3);
insert into t values (-123);
insert into t values (4);
insert into t values (17);
insert into t values (99);
insert into t values (13);

declare r number;begin for x in (select n,mod(rownum,5)r from t) loop if r is null then r:=x.n;elsif x.r=2then r:=r+x.n;elsif x.r=3then r:=r-x.n;elsif x.r=4then r:=r*x.n;elsif x.r=0then r:=r/x.n;else r:=r**x.n;end if;end loop;DBMS_OUTPUT.PUT_LINE(r);end;

আউটপুট:

-1055,356943846277162152071601242992595623

275 বাইট সংস্করণ:

declare r number;cursor c is select n,mod(rownum,5) r from t;begin for x in c loop if r is null then r:=x.n;else case x.r when 2 then r:=r+x.n;when 3 then r:=r-x.n;when 4 then r:=r*x.n;when 0 then r:=r/x.n;else r:=r**x.n; end case;end if;end loop;DBMS_OUTPUT.PUT_LINE(r);end;

— গিয়াকোমো গারাবেলো
সূত্র

3

জাভা 8, 173 172 167 138 137 118 113 বাইট

a->{double r=a[0],t;for(int i=1;i<a.length;r=new double[]{Math.pow(r,t),r+t,r-t,r*t,r/t}[i++%5])t=a[i];return r;}

ব্যাখ্যা:

এখানে চেষ্টা করুন।

a->{                     // Method with double-array parameter and double return-type
  double r=a[0],         //  Result-double, starting at the first item of the input
         t;              //  Temp double
  for(int i=1;           //  Index-integer, starting at the second item
      i<a.length;        //  Loop over the input-array
      r=new double[]{    //    After every iteration, change `r` to:
         Math.pow(r,t),  //      If `i%5` is 0: `r^t`
         r+t,            //      Else-if `i%5` is 1: `r+t`
         r-t,            //      Else-if `i%5` is 2: `r-t`
         r*t,            //      Else-if `i%5` is 3: `r*t`
         r/t}[i++%5])    //      Else-if `i%5` is 4: `r/t`
                         //      And increase `i` by 1 afterwards with `i++`
    t=a[i];              //   Change `t` to the next item in the array
  return r;}             //  Return result-double

— কেভিন ক্রুইজসেন
সূত্র

2

কারণ, আগে কি জানেন, java.1.5 বার বর্তমান দীর্ঘতম উত্তর .... কোনটা SQL এর যে হয় চেয়ে দীর্ঘতর

— Bálint

1

আপনি কিছু বাইট সংরক্ষণ করতে পরিবর্তন double r=a[0];করতে পারেন double r=a[0],b;।

— ফাঁস নুন

1

@ লিকিউন মূলত আমার কাছে ছিল float, তবে ভাসমানদের Math.powজন্য এখানে কিছু নেই , তার doubleবদলে। জন্য ধন্যবাদ ,b। এবং i++<a.lengthআমি একটি পেতে ArrayOutOfBoundsException এ b=a[i];(যদি না আমি কি i++<a.length-1পরিবর্তে, যা এক বাইট খাটো পরিবর্তে আর)।

— কেভিন ক্রুইজসেন

1

আপনি এবং এ পরিবর্তন == 4করতে পারেন । আমি নিশ্চিত নই তবে আমি মনে করি আপনি এর জন্য একটি ভেরিয়েবল তৈরি করে কিছুটা সাশ্রয় করতে পারবেন । > 3== 0< 1i % 5

— হিজরত

1

আমি বুঝতে পেরেছি আপনি পুরো জিনিসটি টেরিনারিগুলির সংমিশ্রণে পরিবর্তন করতে পারেন। সমস্ত তুলনায় আপনি তারপরে <xপুরো ফাংশনটি সঙ্কুচিত করে 137 টি অক্ষরে ব্যবহার করতে পারেন ।

— ফ্রিজড

3

কয়েকটি কৌশল @ উইলমোরের পদ্ধতির 23 থেকে 174 বাইট হ্রাস করতে পারে (পিএইচপি 5.6 বা তার পরে প্রয়োজন)। সর্বাধিক সঞ্চয়কারী অংশটি আনঅ্যাক্সেসারি প্যারেন্টেসিস (-10 বাইট) অপসারণ করছে।

ফাংশন f ($ a) {जबकि (গণনা ($ a)> 1) {$ l = অ্যারে_শিফ্ট ($ ক); $ আর = অ্যারে_শিফ্ট ($ এ); অ্যারে_উন্সফিট ($ এ, ($ জে = $ আই ++% ৫) ? ($ ঞ == 1 $ l- $ R: ($ ঞ == 2 $ ঠ * $ R: ($ ঞ == 3 $ L / $ R: $ ঠ ** $ R))): $ l + $ r);} রিটার্ন শেষ ($ এ);

কিন্তু ব্যবহার **পরিবর্তে অপারেটর pow()ব্যবহার করতে পারবেন evalঅপারেশনের জন্য একটি অ্যারের সঙ্গে; এবং আরও কয়েকটি কৌশল সহ ...

পিএইচপি> = 5.6, 82 বাইট

while(--$argc)eval('$x'.['/','**','+','-','*'][$i++?$i%5:2]."=$argv[$i];");echo$x;

কমান্ড লাইন পরামিতি থেকে তালিকা নেয়। এটি দিয়ে চালান php -nr '<code>'বা অনলাইনে চেষ্টা করুন ।

পুরানো সংস্করণ, 161 157 151 145 144 140 137 117 বাইট

function f($a){while(count($a)>1)eval('$a[0]=array_shift($a)'.['+','-','*','/','**'][$i++%5].'$a[0];');return$a[0];}

সবচেয়ে কার্যকর গল্ফিং মধ্যবর্তী ফলাফলটি সরাসরি প্রথম উপাদানটিতে লেখার মাধ্যমে এসেছিল - অ্যারে থেকে পূর্ববর্তী ফলাফলটি সরিয়ে দেওয়ার পরে।

ভাঙ্গন

function f($a)
{
    while(count($a)>1)  // while array has more than one element ...
        eval('$a[0]='                           // future first element :=
            . 'array_shift($a)'                 // = old first element (removed)
            . ['+','-','*','/','**'][$i++%5]    // (operation)
            .'$a[0];'                           // new first element (after shift)
        );
    return$a[0];        // return last remaining element
}

পরীক্ষা স্যুট

$cases = array (
    0=>[1,2,3,4,5],
    539=>[5,12,23,2,4,4,2,6,7],
    '-1055.356...' => [-8,50,3,3,-123,4,17,99,13],
    256 => [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2],
    1 => [1,0,1,0,1,0],
    -16 => [-9,-8,-1],
    -3 => [0, -3],
    -99 => [-99]
);
echo '<table border=1><tr><th>values</th><th>expected</th><th>actual result</th></tr>';
foreach ($cases as $expect=>$a)
{
    $result=f($a);
    echo "<tr><td>[", implode(',',$a),"]</td><td>$expect</td><td>$result</td></tr>";
}
echo '</table>';

— তিতাস
সূত্র

সুন্দরভাবে সম্পন্ন. অ্যারে হিসাবে শেষ মানটি ফেরত দিয়ে আপনি আরও 3 বাইট সরিয়ে ফেলতে পারেন (পরিবর্তন 'রিটার্ন $ এ [0]' থেকে 'রিটার্ন $ এ'), যা আমি দেখছি না এটি বিশেষত বিধি বিপরীতে। :)

— 640 কেবি

@gwaugh ইমো If the array contains just a single number, we return that as the result.বেশ পরিষ্কার। তবে আমাকে এটি পুনরায় দেখাতে দেওয়ার জন্য ধন্যবাদ।

— তিতাস

কেউ একটি শব্দার্থক তর্ক করতে পারে যে বাক্যে "যে" "অ্যারে" বলতে পারে। নির্বিশেষে, আপনার উত্তরটি এখন পর্যন্ত সংক্ষিপ্ততম পিএইচপি। খুব সুন্দরভাবে সম্পন্ন হয়েছে, এবং আবার আমার দীর্ঘ জমা দেওয়ার পয়েন্টারগুলির জন্য আবার THX।

— 640 কেবি

3

পিএইচপি ,135 130 বাইট

ধন্যবাদ @ টাইটাস, -৫ বাইট, আরও 0 কেস ফিক্স!

function f($z){return array_reduce($z,function($c,$x)use(&$i){eval('$c'.['/','**','+','-','*'][$i++?$i%5:5].'=$x;');return$c;});};

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

কম গোল্ফ:

function f( $t ) {
    return array_reduce( $t,
        function( $c, $x ) use( &$i ) {
            eval('$c'.['/','**','+','-','*'][$i++?$i%5:5].'=$x;');
            return $c;
        }
    );
};

এর জন্য কাজ করার জন্য অ্যারে_ড্রেস () কে সত্যই নির্ধারণ করা হয়েছিল, তবে বর্তমানের সর্বনিম্ন পিএইচপি স্কোরকে পরাস্ত করতে অনেকগুলি অক্ষর প্রয়োজন।

কারও যে কোনও পরামর্শ থাকলে তা পোস্ট করুন!

— 640KB
সূত্র

1

চমৎকার পন্থা; তবে আমি মনে করি এটি যখনই $cহিট হবে ব্যর্থ হবে 0। পরিবর্তে একটি বেনাম ফাংশন দিয়ে দুটি বাইট সংরক্ষণ করুন w। eval('$c'.['/','**','+','-','*'][$i++?$i%5:5].'=$x');return$c;ছয় বাইট ছোট এবং এটি শূন্য সমস্যার সমাধান করা উচিত।

— তিতাস

ধন্যবাদ @ টিটাস! আপনি 0 কেস সম্পর্কে একেবারে সঠিক। আমি ফিরে যোগ করতে হবে; = $ x এর পরে কারণ ইভাল এটি ছাড়া চলবে না। যদি আমি এটি একটি অনন ফাংশন করে থাকি তবে আমাকে এটির একটি পরিবর্তনশীল অ্যাসাইনমেন্ট থাকতে হবে বা এটি পরীক্ষার কোডের মধ্যে চালানো উচিত, তাই না? প্রশ্নে বাইট গণনা কল করতে চান না। : ডি

— 640 কেবি

2

ব্র্যাচল্যাগ , 68 বাইট

hI,?bL,1:+:-:*:/:^b:L:I{bhv?t.|[O:L:I]h$(P,LbM,OhA,Lh:Ir:A&:M:Pr&.}.

এটি দীর্ঘ ... তবে এটি কোনও মূল্যায়নের পূর্বাভাস ব্যবহার করে না।

ব্যাখ্যা

প্রধান শিকারী

hI,                                  Unify I with the first element of the input
   ?bL,                              L is the input minus the first element
       1:+:-:*:/:^b                  Construct the list of predicates [+:-:*:/:^]
                   :L:I{...}.        Call predicate 1 with [[+:-:*:/:^]:L:I] as input

ভবিষ্যদ্বাণী ঘ

bhv?t.                               If the second element of Input is empty (i.e. L),
                                     unify Output with the last element of Input
|                                    Or
[O:L:I]                              Input = [O:L:I]
       h$(P,                         P is O circularly permutated to the left
            LbM,                     M is L minus the first element
                OhA,                 A is the first element of O
                    Lh:Ir:A&         Call predicate A on [I:First element of L]
                            :M:Pr&.  Call predicate 1 recursively with P:M:

— Fatalize
সূত্র

আপনাকে 1̶ ̶b̶y̶t̶e̶ 2 বাইট দ্বারা পরাজিত করুন;)

— লেজিমনম্মল 978

2

আইবিএম পিসি 8087 এফপিইউ, 66 82 বাইট

গণনার জন্য কেবল আইবিএম পিসির ইন্টেল 8087 গণিত-কপ্রোসেসর ব্যবহার করে।

এটি অফলাইনে চেষ্টা করুন! (ডসবক্সে বা যাই হোক না কেন) আপনি 80 এর দশকে আপনি যে লোটাসের 1-2-2 স্প্রেডশিটগুলি ব্যবহার করতেন সেগুলি বাদে আপনার পুরানো পিসির বিরক্ত 8087 চিপকে কিছু করতে দিন।

9bdf 0783 c302 499b de07 83c3 0249 e342 9bde 2783 c302 49e3 399b de0f 83c3 0249 
e330 9bde 3783 c302 49e3 2751 8b0f 9bd9 e883 f900 7413 9c7f 02f7 d99b d8c9 e2fb 
9d7d 069b d9e8 9bd8 f159 83c3 0249 e302 ebb5 c3

অবরুদ্ধ (অবিচ্ছিন্ন):

START: 
    ; RUN TESTS  
    MOV  BX, OFFSET TST     ; 5, 12, 23, 2, 4, 4, 2, 6, 7
    MOV  CX, CTST           ; input array length
    CALL WOMI               ; calculate sequence
    CALL PRINT_FLT          ; output to console

    MOV  BX, OFFSET TST1    ; 5, 12, 23, 2, 4, -4, 2, 6, 7
    MOV  CX, CTST1
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST2    ; -8, 50, 3, 3, -123, 4, 17, 99, 13
    MOV  CX, CTST2
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST3    ; 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
    MOV  CX, CTST3
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST4    ; 1,0,1,0,1,0
    MOV  CX, CTST4
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST5    ; -9, -8, -1
    MOV  CX, CTST5
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST6    ; 0, -3
    MOV  CX, CTST6
    CALL WOMI
    CALL PRINT_FLT

    MOV  AX, 4C00H          ; exit to DOS
    INT  21H

;  TEST DATA

TST   DW  5, 12, 23, 2, 4, 4, 2, 6, 7
CTST  EQU ($-TST)/(SIZE TST)    ; count of items on list

TST1  DW  5, 12, 23, 2, 4, -4, 2, 6, 7
CTST1 EQU ($-TST1)/(SIZE TST1)  ; count of items on list

TST2  DW -8, 50, 3, 3, -123, 4, 17, 99, 13
CTST2 EQU ($-TST2)/(SIZE TST2)  ; count of items on list

TST3  DW 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
CTST3 EQU ($-TST3)/(SIZE TST3)  ; count of items on list

TST4  DW 1,0,1,0,1,0
CTST4 EQU ($-TST4)/(SIZE TST4)  ; count of items on list

TST5  DW -9, -8, -1
CTST5 EQU ($-TST5)/(SIZE TST5)  ; count of items on list

TST6  DW 0, -3
CTST6 EQU ($-TST6)/(SIZE TST6)  ; count of items on list

; 8087 exponent: ST(0) = ST(0) ^ EXP
FIEXP   MACRO   EXP
        LOCAL   REPEAT, DONE
        PUSH CX
        MOV  CX, EXP        ; Exponent is count for loop
        FLD1                ; load 1 into ST
        CMP  CX, 0          ; is exponent pos, neg or 0?
        JZ   DONE           ; exit (with value 1) if exponent is 0
        PUSHF               ; save result flags for later
        JG   REPEAT         ; if exp > 1 start calculation
        NEG  CX             ; make exponent positive for loop
REPEAT:
        FMUL ST(0), ST(1)   ; multiply ST0 = ST0 * ST1
        LOOP REPEAT
        POPF                ; retrieve flags from earlier
        JGE  DONE           ; if exponent was negative, divide 1 by result
        FLD1                ; push 1 into numerator
        FDIV ST(0), ST(1)   ; ST0 = 1 / ST1
DONE:
        POP  CX
        ENDM

; Function WOMI: (Weapons of Math Instruction)
; input: BX - address of start of input array
;       CX - length of input array
; output: ST - result on top of 8087 register stack
WOMI PROC
    FILD WORD PTR [BX]      ; load first item
    ADD  BX, 2              ; move to next
    DEC  CX
CALC:
    FIADD WORD PTR [BX]     ; add
    ADD  BX, 2              ; move to next
    DEC  CX                 ; decrement counter
    JCXZ OUTPUT             ; check if done

    FISUB WORD PTR [BX]     ; subtract
    ADD  BX, 2
    DEC  CX
    JCXZ OUTPUT

    FIMUL WORD PTR [BX]     ; multiply
    ADD  BX, 2
    DEC  CX
    JCXZ OUTPUT

    FIDIV WORD PTR [BX]     ; divide
    ADD  BX, 2
    DEC  CX
    JCXZ OUTPUT

    FIEXP [BX]              ; exponent
    ADD  BX, 2
    DEC  CX
    JCXZ OUTPUT
    JMP CALC                ; start again

OUTPUT:
    RET 
WOMI ENDP

PRINT_FLT PROC
; print top of 8087 stack
; scaling: 14 digits, 4 decimal places
; input: BX = address of a TBYTE (BCD) output buffer
;       ST = value to display on top of 8087 stack  
    LEA   BX, BUFF                  ; set BX to BCD output buffer
    MOV   AH, 2
    MOV   WORD  PTR[BX], 10000      ; ten thousand (scale factor)
    FIMUL WORD  PTR[BX]             ; scale up by 10000
    FBSTP TBYTE PTR[BX]             ; store as BCD
    FWAIT                           ; sync 8088 and 8087
    TEST  BYTE  PTR[BX+9], 80H      ; check sign bit
    JE    PF_1                      ; 0, goto PF_1
    MOV   DL, '-'                   ; output '-'
    INT   21H
PF_1:
    ADD   BX, 8                     ; point to high byte
    MOV   CH, 7                     ; 14 digits before decimal point
    MOV   CL, 4                     ; 4 shifts (8 bytes / 2 = 4 = 1 nibble)
    MOV   DH, 2                     ; 2 times (8 bytes / 4)
PF_LOOP:
    MOV   DL, [BX]                  ; get BCD digits
    SHR   DL, CL                    ; move high digit to low nibble
    OR    DL, 30H                   ; convert to ASCII
    INT   21H
    MOV   DL, [BX]                  ; get byte again
    AND   DL, 0FH                   ; mask out high digit
    OR    DL, 30H                   ; convert to ASCII
    INT   21H                       ; output
    DEC   BX                        ; next byte
    DEC   CH                        ; decrement byte
    JG    PF_LOOP                   ; repeat if more bytes
    DEC   DH                        ; second time?
    JE    PF_DONE                   ; yes, done
    MOV   DL, '.'                   ; no, output decimal point
    INT   21H
    MOV   CH, 2                     ; 4 more digits after decimal point
    JMP   PF_LOOP                   ; go print digits
PF_DONE:
    MOV  DL, 0DH                    ; display newline CRLF
    MOV  AH, 2
    INT  21H
    MOV  DL, 0AH
    INT  21H
    RET 
PRINT_FLT ENDP

BUFF DT 0   ; output buffer for floating point digit string

_TEXT ENDS
END START

আউটপুট:

A>WOMI.COM
00000000000539.0000
-00000000000027.9136
-00000000001055.3569
00000000000256.0000
00000000000001.0000
-00000000000016.0000
-00000000000003.0000

ইনপুটটি একটি প্রোসির মাধ্যমে হয় (কোনও ফাংশনের সমতুল্য x86), বিএক্স মেমরির ডাব্লুএআরডির একটি অ্যারের পয়েন্টার হিসাবে এবং সিএক্স এতে আইটেমের সংখ্যা এবং এসটি-তে ফলাফল প্রদান করে।

* দ্রষ্টব্য: ফাংশনের জন্য আসল কোডটি 6682 বাইট। অবশ্যই কনসোলে একটি ভাসমান পয়েন্ট নম্বর লিখতে কোড (কুকবুক কোড) হল 83 বাইট। টেস্টিং প্রোগ্রাম এবং ডেটা হয়~~183~~215 বাইট, .COM নির্বাহযোগ্য করে তোলে ~~305~~ মোট 380 বাইট

— 640KB
সূত্র

1

এটা অসাধারণ! আমি x86-64 (লিনাক্স) এর জন্য একটি অনুরূপ সমাধান লিখেছি কিন্তু আমি এখনও এটি গল্ফ করি নি যা সম্ভবত প্রায় অনেক যুক্তি পরিবর্তন করবে। আপনার কাফের হিসাবের জন্য, প্রদত্ত পরীক্ষাগুলি নেতিবাচক অভিজাত প্রাপ্তির পরীক্ষা না করলেও আমি অনুভব করেছি যে এটি প্রোগ্রাম যুক্তির একটি প্রয়োজনীয় অংশ, বিশেষত যেহেতু এটি 1 থেকে st0 চাপানো এবং তারপরে st0 এবং 3 এর মধ্যে বিভাজন করার মতোই সহজ st1 (কমপক্ষে x86 এ এটি দুটি নির্দেশ)।

— ডেভি

ধন্যবাদ @ ডেভি - খুব ভাল পয়েন্ট! আমি নেতিবাচক এক্সটেনশনগুলি পরিচালনা করতে কোড আপডেট করেছি এবং এর জন্য আরও একটি পরীক্ষার কেস যুক্ত করেছি।

— 640 কেবি

2

এপিএল (ডায়ালগ ইউনিকোড) , 29 27 বাইট ^{এসবিসিএস}

অনামুখী টাসিট উপসর্গ কার্য। নোট এটি *APL মধ্যে ক্ষয়ক্ষতি হয়।

≢{⍎3↓⍕⌽⍵,¨⍨⍺⍴'+-×÷*',¨'⍨'}⊢

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

এপিএল ডান থেকে বাম চালায় তাই, আমরা কেবল sertedোকানো ক্রিয়াকলাপগুলির আর্গুমেন্টের ক্রমটিকে বিপরীত করতে এবং পুরো অভিব্যক্তিটি বিপরীত করতে পারি। পোস্টফিক্স ⍨আর্গুমেন্টগুলি বিপরীত করে। সংখ্যা এবং ক্রিয়াকলাপের একটি নিখুঁত রদবদল করার পরে আমাদের কেবল বিপরীত, সমতল এবং মূল্যায়ন করতে হবে:

≢{... }⊢ গণনা এবং প্রকৃত সংখ্যার নিম্নলিখিত ফাংশন কল ⍺এবং ⍵:

'⍨' এই চরিত্র

'+-×÷*',¨ এই চরিত্রগুলির প্রত্যেকটিকে আগে যুক্ত করুন; ["+⍨","-⍨","×⍨","÷⍨","*⍨"]

⍺⍴ cyclically বাম যুক্তি (সংখ্যার গণনা) ব্যবহার দ eshape যে

⌽ বিপরীত

⍕ ফ্ল্যাট স্ট্রিং হিসাবে ফর্ম্যাট

3↓শীর্ষস্থানীয় 3 টি অক্ষর (একটি স্থান এবং একটি প্রতীক এবং ⍨) বাদ দিন

⍎ এপিএল কোড হিসাবে চালিত

— আদম
সূত্র

2

জাপট , 16 বাইট

r@[XY]r"p+-*/"gZ

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

ব্যাখ্যা:

r@                  #Reduce the input list:
       "p+-*/"      # The list of functions to apply (offset by one due to the behavior of Z)
              gZ    # Choose the one at the current index, wrapping
  [  ]r             # Apply that function to:
   X                #  The result of the previous step
    Y               #  and the current number
                    #Implicitly return the result of the final step

— কামিল দ্রাকারী
সূত্র

আহ, অদ্ভুত, আমি নিজেই এটি নিয়ে কাজ করছিলাম, কেন এটি আমাকে ভুল ফলাফল দিচ্ছে তা জানার চেষ্টা করছিলাম - আমি অনুভবের ক্ষয়ক্ষতি মিস করেছি! : \

— শেগি

1

সি #, 238 , 202 বাইট

double d(double[]a){Array.Reverse(a);var s=new Stack<double>(a);int i=0,j;while(s.Count>1){double l=s.Pop(),r=s.Pop();j=i++%5;s.Push(j==0?l+r:j==1?l-r:j==2?l*r:j==3?l/r:Math.Pow(l,r));}return s.Peek();}

আমি কোনও সি # সমাধান দেখিনি তাই আমি একটি দেব। এটি আমার প্রথম কোডগল্ফ। আমি সি # "দু'মাস আগে" লিখতে শুরু করেছি (যদিও আমি কিছুটা জাভা জানি)।

এটি স্ট্যাক ব্যবহার করে

অবহেলিত এবং পরীক্ষার মামলা

using System;
using System.Collections.Generic;

class M 
{
    double d(double[]a) {
        Array.Reverse(a);
        var s = new Stack<double>(a);
        int i=0,j;
        while (s.Count>1)
        {
            double l=s.Pop(),r=s.Pop();
            j=i++%5;
            s.Push(j==0?l+r:j==1?l-r:j==2?l*r:j==3?l/r:Math.Pow(l, r));
        }
        return s.Peek();
    }

    public static void Main()
    {
        int[][] a = new int[][]{
            new int[]{1,2,3,4,5},
            new int[]{5,12,23,2,4,4,2,6,7},
            new int[]{-8,50,3,3,-123,4,17,99,13},
            new int[]{2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
            new int[]{1,0,1,0,1,0},
            new int[]{-9,-8,-1},
            new int[]{0,-3},
            new int[]{-99}
        };

        for (int i = 0; i < a.Length; i++)
        {
            Console.WriteLine(new M().d(Array.ConvertAll(a[i], e => Convert.ToDouble(e))));
        }
        Console.ReadKey();
    }
}

আউটপুট:

0
539
-1055,35694384628
256
1
-16
-3
-99

— DISPLAY_NAME
সূত্র

হাই, এবং পিপিসিজিতে আপনাকে স্বাগতম! এটি দেখতে একটি দুর্দান্ত বিষয় হতে পারে: সি # তে কোড-গল্ফ করার টিপস । আপনার কোডে কিছু জিনিস যা গল্ফ করা যেতে পারে: স্পেসস ( a, Double.Parse-> a,Double.Parse; while (s.Count-> while(s.Count; Pow(l, r)-> Pow(l,r))। এছাড়াও, আপনি int এর সামনে সরিয়ে j=এটিকে পিছনে রাখতে পারেন int i=0,j;। যদিও দুর্দান্ত প্রথম উত্তর, এবং আবারো স্বাগতম। :)

— কেভিন ক্রুজসসেন

নিবন্ধন করুন Ty! শূন্যস্থানের মুছে ফেলেছি এবং ঞ সরানো হিসাবে আপনি পরামর্শ :)

— DISPLAY_NAME

1

পিএইচপি, 206 , 198 , 197 বাইট

function f($a){while(count($a)>1){$l=array_shift($a);$r=array_shift($a);array_unshift($a,($j=$i++%5)==0?($l+$r):($j==1?($l-$r):($j==2?($l*$r):($j==3?($l/$r):(pow($l,$r))))));}return array_pop($a);}

Ungolfed

<?php

function f($a)
{
    while(count($a)>1)
    {
        $l = array_shift($a); $r = array_shift($a);
        array_unshift($a,($j=$i++%5)==0?($l+$r):($j==1?($l-$r):($j==2?($l*$r):($j==3?($l/$r):(pow($l,$r))))));
    }
    return array_pop($a);
}

echo f([1,2,3,4,5])."\n";
echo f([5,12,23,2,4,4,2,6,7])."\n";
echo f([-8,50,3,3,-123,4,17,99,13])."\n";
echo f([2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2])."\n";
echo f([1,0,1,0,1,0])."\n";
echo f([-9,-8,-1])."\n";
echo f([0,-3])."\n";
echo f([-99])."\n";

পিএইচপি-তে, আমার সি # উত্তর ( 202 বাইট ) এর মতো যুক্তিযুক্ত :)।

— DISPLAY_NAME
সূত্র

গণিত নির্দেশের অস্ত্র

জেলি , 13 বাইট

কিভাবে এটা কাজ করে

জাভাস্ক্রিপ্ট ES7 49 বাইট

হাস্কেল, 76 65 64 62 বাইট

পাইকে, 22 21 বাইট

হাস্কেল, 61 বাইট

টিএসকিউএল 116 115 88 বাইট

পাইথ, 27 26 25 বাইট

ইতিহাস

আসলে, 23 বাইট

ব্যাখ্যা:

জুলিয়া, 53 50 বাইট

জে, 40 বাইট

ব্যবহার

ব্যাখ্যা

পাইথন 2, 81 67 64 বাইট

কিভাবে এটা কাজ করে

মতলব - 95 91 85 বাইট / অক্টেভ - 81 বাইট

গণিত, 67 67 65 বাইট

সিজেম, 18 বাইট

কিভাবে এটা কাজ করে

আর , 87 78 70 বাইট

হাস্কেল - 74

পাওয়ারশেল ভি 2 +, 124 বাইট

মরিচা, 123 , 117 বাইট

পার্ল 6 , 70 68 65 62 বাইট

ব্যাখ্যা:

টেস্ট:

পাইথন 3, 88 93 বাইট

ওরাকল পিএল / এসকিউএল, 275 254 বাইট

275 বাইট সংস্করণ:

জাভা 8, 173 172 167 138 137 118 113 বাইট

পিএইচপি> = 5.6, 82 বাইট

পুরানো সংস্করণ, 161 157 151 145 144 140 137 117 বাইট

পিএইচপি ,135 130 বাইট

ব্র্যাচল্যাগ , 68 বাইট

ব্যাখ্যা

আইবিএম পিসি 8087 এফপিইউ, 66 82 বাইট

এপিএল (ডায়ালগ ইউনিকোড) , 29 27 বাইট এসবিসিএস

জাপট , 16 বাইট

সি #, 238 , 202 বাইট

পিএইচপি, 206 , 198 , 197 বাইট

এপিএল (ডায়ালগ ইউনিকোড) , 29 27 বাইট ^{এসবিসিএস}