逆向数学循环

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 
— 开斋节
source
沙盒（仅2k +）
— caird coinheringaahing 2009年
@AdmBorkBork他正在解决这个问题，我在聊天中指出。
— Xcoder先生17年
@AdmBorkBork已更正。我在测试用例生成器中错过了这一点
— Caird coinheringaahing
您的第三个测试用例仍包含0>。>
— Xcoder先生，2017年
1
@DigitalTrauma对于默认为整数的语言，我认为对于这样的小数字，输出0是可以接受的。
— caird coinheringaahing

Answers:

6

果冻，10个字节（fork）

+×_:%*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
— 英里
source
whaaaaaaaat真的来了:(但很好，这个快速操作似乎很有用：D
— HyperNeutrino
这需要拉到果冻。+1，尽管您可能还想扩展ƭ以支持nilads（替换值）和monads（应用于左参数）
— Erik the Outgolfer
@EriktheOutgolfer它已经适用于monad。请参阅我在Jelly聊天中发布的示例。尼拉德则不同。
— 英里
@miles我的意思是就像尼拉德人在这里的举止一样。
— Erik the Outgolfer
@EriktheOutgolfer好吧，它现在支持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%^↔
— 普维兹
source
出于好奇，您为什么不能这样做ë+*-÷%^？为什么要这样做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
— 艾米尼亚
source
Ig∍如果您想使用“ newish”命令（∍在这里没有看到太多）。
— 魔术章鱼缸
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]
— 乔纳森·艾伦
source
使用ż“+×_:%*”;"ṚV
— Outgolfer埃里克（Erik the Outgolfer）
@EriktheOutgolfer仅在输入长度恰好为6时才起作用。我认为您也需要这样做ż“+×_:%*”ṁ$;"ṚV，它也是15个字节。
— 乔纳森·艾伦，
好吧，我在想什么...我真想念“ tie” :(
— Erik the Outgolfer
2

JavaScript（ES7），68 67字节

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

显示代码段

— Arnauld
source
不错的解决方案！也许您可以移动o括号内的分配.pop()以节省一些字节。
— 路加福音
@Luke的分配o也用作三元运算符的条件。那会破坏那个计划。
— Arnauld
@毛茸茸。那与阿尔纳德的第一个答案完全相同。
@ThePirateBay：啊。在SE移动版上，因此看不到编辑历史记录。
— 毛茸茸的
2

Perl 6，67 66个字节

感谢@nwellnhof，节省了1个字节。

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

在线尝试！

非常缺乏想象力（可能很糟糕）的解决方案。使论点自成一体，相反。然后，将结果列表与EVAL作为字符串的块映射a (operator) b。<+ * - div % **>使用free state（static从C 认为-该值在块的调用之间持续存在）变量从字符串列表中选择运算符$。分别为每个块创建该对象并将其设置为0。您可以对其进行任何操作，但是只能引用一次（$实际上，每次出现都引用另一个变量）。因此$++%6，实际上在第一次呼叫期间为0，在第二次呼叫期间为1，在第六次呼叫时为... 5，在第七次呼叫时为0，依此类推。

我起初试着不做任何事EVAL。运算符实际上只是subs（=函数），但是它们的名称非常笨拙（&infix:<+>以此类推），以至于我不得不放弃这种方法。

— 拉米利斯
source
map {EVAL ".[0] ... .[1]"},zip $_,.reverse短1个字节。
— nwellnhof
@nwellnhof，谢谢！
— 拉米利斯
2

Haskell中，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个字节

当然，有更好的方法可以实现这一目标。

编辑 1.固定整数的指数；2.绝对有更好的方法，请参见下面的注释：95 91字节

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

在线尝试！

— 杰费拉德
source
zipWith3($)(cycle[(+),(*),(-),div,mod,(^)])<*>reverse是您的短版（现已删除）。
— H.PWiz
@ H.PWiz我一直在寻找类似的东西，但没有时间进一步寻找。为什么删除它？我相信不禁止在同一语言中使用两种不同的解决方案，尤其是当一种解决方案远胜于另一种解决方案时……
— jferard
@ H.PWiz固定指数。
— jferard
不需要：h的调用，否则，您可以内联（TIO）。oo a bh
— nimi
1

， 44 42字节

划掉44 yada yada ...

-2个字节，感谢@ ConorO'Brien

_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

一些注意事项：

J没有整数除法，因此我们将%-division与>.-floor 组成。J的mod（|）与我们期望的相反，因此我们必须使用~-reflexive 反转其顺序。

即使我们以2为间隔移动，我们也必须使用/-insert插入动词以使其被动态使用，因为\-infix是这样工作的。

— 油菜
source
我也很想知道如何避免所有()重复的事情/–我无法弄清楚
— Jonah
@Jonah，最好的是，我想到的是类似/带有反向动词的反向数组（因为它向后操作...），(,+)`(,*)但这并没有太大帮助...（也行不通）
— cole
1
Gerund可以是+/`(*/)`...
— Conor O'Brien
1

红宝石，63 57字节

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

没什么，真的。只需在数组上进行迭代，使用索引作为反向迭代器，使用正确的运算符将其加入字符串中，即可进行评估，冲洗和重复。

在线尝试！

— 国标
source
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
source
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
— 西纳斯基
source
0

R，74字节

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

在线尝试！

这是我想出的最终答案。它返回一个长度列表，length(l)其中每个元素都是包含相应元素的列表。有点儿cr脚，但他们都在那里。如果这是不可接受的，则Map可以用mapply+3个字节替换其中一个。

由于R运算符都是函数（中缀表示法只是语法糖），因此我尝试从列表中选择一个；例如，下面的94个字节的解决方案。

为了尝试摆脱循环，我尝试了sapply，但这仅适用于单个函数和输入列表。然后我想起多元形式，mapply，这需要一个n-ary函数FUN和n后续参数，适用FUN于每个参数的第一个，第二个，...元素，并在必要时进行回收。还有一个包装的功能mapply，Map即“没有试图简化的结果”。因为短了三个字节，所以这是一个很好的高尔夫机会。

因此，我定义了一个三进制函数（如下面的80字节解决方案），该函数将一个函数作为第一个参数，并将其应用于第二个和第三个参数。但是，我意识到这Map是一个将函数作为其第一个参数并将其应用于后续参数的函数。整齐！

最后，我们在最后添加子集以确保仅返回第一个 length(l)值。

R，80个字节

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

在线尝试！

这将不起作用，因为它将为少于6个元素的列表返回6个值。

[R，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下面的方法更好。

[R，100字节

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

在线尝试！

这是eval我能找到的最短的方法。因为我们要收集结果到一个载体，我们需要paste一个c( )身边所有的表述，增加了一吨不必要的字节

— 朱塞佩
source
0

Casio-Basic，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时候，这意味着我必须创建自己的 mod函数：因此x-int(x/y)y。

i从0 循环到length(l)-1，将o列表中的连续元素作为并l[i]为x和l[-i]申请y。（负索引虽然无效，所以我减去了i从列表的长度中并获取该索引。）

该功能需要107个字节，要l在参数框中添加+1个字节。

— 疯子
source
0

Java 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个字节（输入as 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
— 凯文·克鲁伊森
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.