Esinlenen bu

Bağlantılı mücadelede, orijinalin elemanlarına ve giriş dizisinin tersine ekleme yapmamız istenir. Bu zorlukta, diğer temel matematik işlemlerini tanıtarak biraz daha zorlaştıracağız.

Tamsayı dizisi yoluyla çevrim göz önüne alındığında +, *, -, //, %, ^, //bölünme tamsayıdır ve ^dizinin ters için uygulanırken, üssüdür. Ya da başka bir deyişle, yukarıdaki işlevlerden birini dizinin her öğesine uygulayın, ikinci argüman dizinin tersidir, işlev yukarıdaki listeden geçerken uygulanır. Bu hala kafa karıştırıcı olabilir, bu yüzden bir örnek üzerinden çalışalım.

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]

böylece için çıkış [1, 2, 3, 4, 5, 6, 7, 8, 9]olacağını[10, 16, -4, 0, 0, 1296, 10, 16, 8]

Köşe vakalarını kapatmak için, girdi hiçbir zaman 0 içermez, ancak negatif sonsuzdan pozitif sonsuza kadar başka bir tamsayı içerebilir. İsterseniz, basamağı temsil eden dizelerin listesi olarak girdi alabilirsiniz.

Test senaryoları

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]

Bu bir kod golf çok kısa kod (bayt cinsinden) kazanır!

Jöle, 10 bayt ( çatal )

+×_:%*6ƭ"Ṛ

Geçen gün bunun için hızlı bir uygulama yapmaya çalışıyordum, bu yüzden yakında bir kullanım görmek oldukça şaşırtıcı. Hala sadece çatal olarak var, bu yüzden çevrimiçi olarak deneyemezsiniz.

Örnek çıktı

$ ./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]

açıklama

+×_:%*6ƭ"Ṛ  Input: array
      6ƭ    Tie 6 dyads
+             Addition
 ×            Multiplication
  _           Subtraction
   :          Integer division
    %         Modulo
     *        Power
        "   Vectorize with
         Ṛ  Reverse

Kabuk , 16 bayt

Bu zorluk, sonsuz işlev listesi oluşturabilen dilleri desteklemektedir. Belki değil, evalFTW

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

Çevrimiçi deneyin!

Nasıl?

  ¢+ë+*-÷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      ]

Alternatif 17 bayt çözümü:

ṠozIzI¢+ë+*-÷e%^↔

05AB1E , 18 bayt

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

Çevrimiçi deneyin!

açıklama

                    # 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

Bash + GNU yardımcı programları, 53

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

Bu komut dosyası, komut satırı parametresi olarak bir dosya adı alır.

Çevrimiçi deneyin .

Buradaki güzel şey paste -d, döngüsel olarak kullanılan ayırıcıların bir listesinin verilmesine izin vermesidir. Gerisi sadece bunu yapmak için girişi doğru formata alıyor.

Jöle , 15 bayt

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

Çevrimiçi deneyin! veya test takımına bakın .

Nasıl?

żṚ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]

Python 2 , 67 bayt

Ovs sayesinde -3 bayt.

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

Çevrimiçi deneyin!

Python 2 , 95 bayt

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

Çevrimiçi deneyin!

evalşeytani ... ama belki daha golfçü. : P

JavaScript (ES7), 68 67 bayt

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

let f =

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

console.log(JSON.stringify(f([1, 2, 3, 4, 5, 6, 7, 8, 9]    ))) // [10, 16, -4, 0, 0, 1296, 10, 16, 8]
console.log(JSON.stringify(f([5, 3, 6, 1, 1]                ))) // [6, 3, 0, 0, 1]
console.log(JSON.stringify(f([2, 1, 8]                      ))) // [10, 1, 6]
console.log(JSON.stringify(f([11, 4, -17, 15, 2, 361, 5, 28]))) // [39, 20, -378, 7, 2, 3.32948887119979e-44, 9, 308]

Perl 6 ,67 66 bayt

@Nwellnhof sayesinde 1 bayt kaydedildi.

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

Çevrimiçi deneyin!

Çok yaratıcı olmayan (ve muhtemelen kötü) bir çözüm. Tartışmayı kendisi tersine çevirir. Elde edilen liste daha sonra EVALdizge olan blokla eşlenir a (operator) b. İşleç, <+ * - div % **>free state( staticC dilinde düşünün - değer blok çağrıları boyunca devam eder) değişkenini kullanarak dizeler listesinden seçilir $. Bu, her blok için ayrı ayrı oluşturulur ve 0 olarak ayarlanır. Onunla istediğiniz her şeyi yapabilirsiniz, ancak sadece bir kez başvurabilirsiniz ( $aslında her bir oluşum başka bir değişkeni ifade eder). Yani $++%67. ve benzeri sırasında 6., 0 boyunca saniye ... 5 sırasında aslında 0 ilk çağrıdan 1 sırasındadır.

İlk başta bir olmadan yapmaya çalıştım EVAL. Operatörler aslında sadece subs (= fonksiyonlar), ama isimleri o kadar çok ungolfy ( &infix:<+>ve benzeri) bu yaklaşımı terk etmek zorunda kaldı.

Haskell , 74 117 105 bayt

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

Çevrimiçi deneyin!

@Nimi sayesinde 12 bayt kaydedildi

Bunu başarmanın kesinlikle daha iyi bir yolu var.

EDIT 1. Tamsayılar için sabit üs; 2. Kesinlikle daha iyi bir yol var, aşağıdaki yoruma bakın: 95 91 bayt

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

Çevrimiçi deneyin!

Python 2 , 71 bayt

lambda l:[eval(y+'+*-/%*'[x%6]*-~(x%6>4)+l[~x])for x,y in enumerate(l)]

Çevrimiçi deneyin!

Ovs sayesinde 2 bayt kaydedildi!

J, ₄₄ 42 bayt

44'ü geçti, yada yada ...

@ ConorO'Brien sayesinde -2 bayt

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

Çevrimiçi deneyin!

Çok fazla parens ve insert ... Elbette bunu yapmanın daha iyi bir yolu var (belki infix yerine insert kullanmak?)

açıklama

_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

Bazı notlar:

J'nin tamsayı bölümü yoktur, bu yüzden %-floor ile -bölüm oluştururuz >.. J's mod ( |), beklediğimiz şeyin tersini yapar, bu yüzden sırasını kullanarak~ -reflexive çevirmeliyiz.

2 aralıkta hareket /etsek de, fiilleri ikili olarak kullanmak için fiilleri eklemek için -inert kullanmalıyız çünkü \-infix böyle çalışır.

Yakut , 63 57 bayt

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

Hiçbir şey fantezi değil, gerçekten. Sadece diziyi yineleyin, ters yineleyici olarak bir dizin kullanın, doğru operatörü kullanarak bir dizeye katılın, değerlendirin, durulayın ve tekrarlayın.

Çevrimiçi deneyin!

k , 40 bayt

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

Çevrimiçi deneyin!

{                                      } /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

MATL ,27 23 bayt

@LuisMendo sayesinde -4 bayt

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

Çevrimiçi deneyin!

Açıklama:

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

Perl 5 , 68 + 1 (-p) = 69 bayt

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

Çevrimiçi deneyin!

Girdileri boşlukla ayrılmış sayı listesi olarak alır.

R , 74 bayt

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

Çevrimiçi deneyin!

Bu geldiğim son cevap. length(l)Her öğenin karşılık gelen öğeyi içeren bir liste olduğu bir uzunluk listesi döndürür . Biraz berbat ama hepsi orada. Bu kabul edilemezse,Mapmapply +3 bayt ile değiştirilebilir .

R operatörlerinin hepsi fonksiyon olduğundan (infix gösterimi sadece sözdizimsel şeker), listeden bir tane seçmeye çalıştım; örneğin, aşağıdaki 94 baytlık çözelti.

Döngüden kurtulmak için denedim sapply, ama bu sadece tek bir işlev ve giriş listesi ile çalışıyor. Daha sonra mapply, bir n-aryişlevi alan FUNve nsonraki argümanları alan, her bir argümanın FUNilk, ikinci, ... öğelerine uygulanan, gerekirse geri dönüşüm yapan çok değişkenli formu hatırladım . Ayrıca bir sarıcı işlevi vardırmapply , Mapo "sonucunu basitleştirmek için hiçbir girişimde bulunmaz" . Üç bayt daha kısa olduğu için iyi bir golf fırsatı.

Bu nedenle, bir işlevi ilk argümanı olarak alan ve ikinci ve üçüncü işlevlerine uygulayan üçlü bir işlev (aşağıdaki 80 baytlık çözümde olduğu gibi) tanımladım. Ancak fark ettim kiMap bunun ilk argüman olarak bir işlevi alan ve onu ardışık olanlara uygulayan bir işlev olduğunu . Temiz!

Son olarak, yalnızca ilkini döndürdüğümüzden emin olmak için sonunda alt kümeleriz length(l) değerleri .

R , 80 bayt

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

Çevrimiçi deneyin!

Bu, işe yaramaz, çünkü 6'dan az elemanı olan listeler için 6 değer döndürür.

R , 94 bayt

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

Çevrimiçi deneyin!

Açıklama (hafif soluksuz):

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
}

İşlevlerin her biri vektörleştirildiğinden, sonunda ( res[i]) indeksleyebiliriz . Bu, evalaşağıdaki yaklaşımdan daha iyidir .

R , 100 bayt

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

Çevrimiçi deneyin!

Bulabildiğim en kısa evalyaklaşım; biz bir vektör içine sonuçları toplamak zorunda çünkü biz gereken pastebir c( )gereksiz bayt bir ton ekler her yerinde ifadeler

Casio-Basic, 108 bayt

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

Acı vericiydi. Özellikle , gerçekten olmaması gerektiğinde mod(x,y)geri döner x, bu da kendi mod işlevimi yapmak zorunda olduğum anlamına geliyordu : dolayısıyla x-int(x/y)y.

Döngüler i0'dan length(l)-1, birbirini izleyen elemanlar alarak olistesi ve uygulamak l[i]için xve l[-i]için y. (negatif indeksler işe yaramıyor, bunun yerine çıkarıyorumi listenin uzunluğundan ve bu dizini alırım.)

Fonksiyon için 107 bayt l, parametre kutusuna eklenecek +1 bayt .

Java 8, 336 bayt

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

Burada deneyin.

İç çekme .. Olarak
giriş int[], çıkış olarak java.math.BigInteger[].

Kural olmadan " köşe durumlarda karşılamak için, giriş 0 değerini ihtiva asla ama olumlu sonsuza negatif sonsuza aralığında başka tamsayı içerebilir. ", Aralıktaki tamsayılar kullanarak -2147483648etmek 2147483647, öyle olurdu 186 bayt (giriş as int[]ve çıkış yok çünkü baytları kaydetmek için bu girdi dizisini değiştirir)

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

Burada deneyin.

Açıklama:

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