从偶数中减去赔率


19

给定一个非负整数,返回其偶数位和与奇数位之和之间的绝对差。

默认规则

  • 适用标准漏洞。

  • 您可以通过任何标准的输入/输出方法进行输入并提供输出。

  • 您可以将输入作为字符串,整数或数字列表。

  • 这是,因此每种语言中以字节为单位的最短代码胜出!

测试用例

输入〜>输出

0〜> 0(| 0-0 | = 0)
1〜> 1(| 1-0 | = 1)
12〜> 1(| 2-1 | = 1)
333〜> 9(| 0-(3 + 3 + 3)| = 9)
459〜> 10(| 4-(5 + 9)| = 10)
2469〜> 3(|(2 + 4 + 6)-9 | = 3)
1234〜> 2(|(2 + 4)-(1 + 3)| = 2)

1
我们可以将输入作为整数列表吗?
亚当

4
@ Mr.Xcoder不会太琐碎。它使挑战变得不必要地复杂,并且是添加字节的任意要求。
Okx

4
@ Mr.Xcoder 不要挑战变色龙。您可能想在这里看到的最重要的一句话是将两个或多个不相关的核心挑战合并为一个-考虑将挑战分解为单独的挑战或删除不必要的部分
Okx

1
* chamel ê上的挑战
CalculatorFeline

1
我已经更改了规则@Okx。以作为数字列表现在允许。我仍然不认为这会使它蓬松。
Xcoder先生17年

Answers:


8

果冻,6个字节

-*æ.¹A

在线尝试!

怎么运行的

-*æ.¹A  Main link. Argument: A (digit array)

-*      Raise -1 to A's digits, yielding 1 for even digits and -1 for odd ones.
    ¹   Identity; yield A.
  æ.    Take the dot product of the units and the digits.
     A  Apply absolute value.

通过将输入作为列表可以节省1个字节。
CalculatorFeline

正在考虑输入为列表。
丹尼斯

我说的是修订版
CalculatorFeline

Raise -1 to A's digits, yielding 1 for even digits and 0 for odd ones.嗯,我想你把事情弄乱了……
暴民埃里克(Erik the Outgolfer)

2
@EriktheOutgolfer达恩一字不漏的错误。
丹尼斯,

8

深圳I / O MCxxxx脚本,197(126 + 71)字节

芯片1(MC6000):

  • x0:输入为列表
  • x2:芯片2 x1
  • x3:MC4010
mov 0 dat
j:
mov x0 acc
mov 70 x3
mov -1 x3
mov acc x3
mul x3
mov acc x2
mov dat acc
add 1
tlt acc 3
mov acc dat
+jmp j
slx x0

芯片2(MC4000):

  • p0:输出
  • x0:MC4010
  • x1:芯片1 x2
mov x1 acc
add x1
add x1
mov 30 x0
mov 0 x0
mov acc x0
mov x0 p0
slx x1

1
(您能给我们一个<!-- -->评论,以获得正确的代码清单之后,而不是填充文本或缩进代码4多个空格。)
马太福音


5

TI基本(18 9个字节)

abs(sum((-1)^AnsAns

说明

将列表中的每个数字乘以-1乘以其幂,然后将每个奇数取反,然后将它们相加。



4

R,30 29字节

abs(sum((d=scan())-2*d*d%%2))

d = scan() 将输入数字后接一个数字。

-1个字节感谢@Giuseppe!


这非常好!不过,可以节省1个字节:abs(sum((d=scan())-2*d*d%%2))
Giuseppe

@Giuseppe谢谢,很好的提示,已编辑!
Nutle

4

C#,57个字节

namespace System.Linq{i=>Math.Abs(i.Sum(n=>n%2<1?n:-n))}

将输入取为i并通过将赔率设为负数来对整数求和。


这里第一个答案。如果我需要将整个东西包装到一个实际的C#程序中并且也要计算这些字节,就不知道了。
TyCobb '17

您必须包括样板namespace System.Linq{并进行实际功能。请参阅参考其他C#的答案
Xcoder先生

@ Mr.Xcoder感谢您的信息。想我知道。我的字节数几乎翻倍=(大声笑
TyCobb

是的,C#并不是真正的最佳高尔夫语言
Xcoder先生17年

@ Mr.Xcoder Nope,但是我认为规则放宽了,因为我在首页上看到了一个细长的版本,没有名称空间的内容,也没有看到Main。我以为我会回答的唯一原因。哦,天哪。
TyCobb '17

4

Mathematica,20个字节

Abs@Tr[(-1)^(g=#)g]&

输入数字列表

@LLlAMnYP的特殊感谢,让我了解“新规则”


击败我!:)您可能不需要*
格雷格·马丁

现在,OP放松了对您的代码的要求,可以使它变得短得多。+1
LLlAMnYP'7

3

Japt,8字节

x_*JpZÃa

在线测试!

说明

 x_  *JpZÃ a
UxZ{Z*JpZ} a
                Implicit: U = list of digits
UxZ{     }      Take the sum of each item Z in U mapped through the following function:
      JpZ         Return (-1) ** Z
    Z*            times Z. This gives Z if even, -Z if odd.
           a    Take the absolute value of the result.
                Implicit: output result of last expression

3

Neim,7个字节

ΓDᛃΞ𝐍}𝐬

说明:

Γ        Apply the following to each element in the input array
 D         Duplicate
  ᛃ        Modulo 2, then perform logical NOT
   Ξ       If truthy, then:
    𝐍        Multiply by -1
      }  Close all currently running loops/conditionals etc
       𝐬 Sum the resulting array

谁没有内建2的mod,然后逻辑上不会得到结果?
caird coinheringaahing

@cairdcoinheringaahing基本上是“检查是否偶数”
Okx

3

APL,8个字节

|⊢+.ׯ1*⊢

在线尝试!

怎么样?

¯1*⊢- -1 ñ对于n

[ 4 5 91 ¯1 ¯1]

⊢+.×-用o求和,然后求和

[ +/ 4 5 9 × 1 ¯1 ¯1→交通+/ 4 ¯5 ¯9→交通¯10]

| - 绝对值


您能提供一个测试环境吗?
Xcoder先生17年

@ Mr.Xcoder加
尤利尔

|⊢+.ׯ1*⊢新的输入规格。
亚当

@Adám谢谢。不能相信我错过了产品。
Uriel's

您可以在说明中提供更多详细信息吗?可以将此方法移植到J吗?我当前正在使用密钥(请参阅我的答案),但是此方法可能会删除一些字节...
乔纳

3

JavaScript(ES6),43 38字节

将输入作为数字数组组成的字符串

a=>a.map(d=>s+=d&1?d:-d,s=0)&&s>0?s:-s

测试用例


3

编辑:一种更以高尔夫为中心的方法:

EXCEL,42 36 29字节

借助Magic Octopus Urn节省了6个字节,使用Dennis的-1 ^方法节省了7个字节(我刚刚了解到,它可以在Excel中处理数组)

=ABS(SUMPRODUCT(A:A,-1^A:A))

在A列中获取一个整数列表作为输入。可能可以进一步打高尔夫球,或者使用弦乐版本,在A1中取一个弦乐作为输入。

EXCEL,256个字节

=ABS(LEN(SUBSTITUTE(A1,1,""))-2*LEN(SUBSTITUTE(A1,2,""))+3*LEN(SUBSTITUTE(A1,3,""))-4*LEN(SUBSTITUTE(A1,4,""))+5*LEN(SUBSTITUTE(A1,5,""))-6*LEN(SUBSTITUTE(A1,6,""))+7*LEN(SUBSTITUTE(A1,7,""))-8*LEN(SUBSTITUTE(A1,8,""))+9*LEN(SUBSTITUTE(A1,9,""))-5*LEN(A1))

在此处输入图片说明


1
免责声明,仅适用于长度小于100的数字
Magic Octopus Urn'Jul

1
切换到A:A可节省6个字节并消除该问题。
标记

哇,我的建设性批评很少为您的Excel知识先生节省字节,+ 1。
魔术章鱼缸

另外,由于You may take input as a String, as an Integer or as a list of digits.您的42字节答案应该是您使用的答案。
魔术八达通Ur

第一次是幽默的尝试,但我将其切换。
标记


2

外壳,7个字节

≠0ṁṠ!¡_

在线尝试!

将数字列表作为输入。

仍然缺少内置的“ abs”,但效果都很好:)

说明

Ṡ!¡_是一个接受数字的函数,n然后n-1将该函数_(负数)应用于n。这导致n奇数n-n偶数n

将函数应用于列表的每个元素,并对结果求和。

≠0 返回数字和0之间的绝对差。


2

05AB1E,6个字节

感谢Dennis的-1技巧。将输入作为数字列表

®sm*OÄ

在线尝试!

说明

®sm*OÄ                                               Example [4, 5, 9]
®      # Push -1                                   % STACK: -1
 sm    # Take -1 to the power of every number      % STACK: [1, -1, -1]
         in the input list 
   *   # Multiply with original input              % Multiply [1, -1, -1] with [4, 5, 9] results in STACK: [4, -5, -9]
    O  # Sum them all together                     % STACK: -10
     Ä # Absolute value                            % STACK: 10
       # Implicit print

我听不懂解释。请您添加一个例子。
泰特斯

@Titus你去了。希望对您
有所

在这里,我È2*<*O像个肮脏的随便。
魔术章鱼缸

2

PHP,51字节

while(~$n=$argn[$i++])$s+=$n&1?$n:-$n;echo abs($s);

$s如果奇数加数字,如果偶数减。与管道一起运行-nR

要么

while(~$n=$argn[$i++])$s+=(-1)**$n*$n;echo abs($s);

使用丹尼斯的-1技巧。


2

Mathematica,67个字节

(s=#;Abs[Subtract@@(Tr@Select[IntegerDigits@s,#]&/@{EvenQ,OddQ})])&

2

PHP,54字节

for(;~$n=$argn[$i++];)${eo[$n&1]}+=$n;echo abs($e-$o);

在线尝试!

PHP,57字节

将偶数和奇数和存储在数组中

for(;~$n=$argn[$i++];)$r[$n&1]+=$n;echo abs($r[0]-$r[1]);

在线尝试!

PHP,57字节

将偶数和奇数和存储在两个变量中

for(;~$n=$argn[$i++];)$n&1?$o+=$n:$e+=$n;echo abs($e-$o);

在线尝试!


54个字节:奇数${1}和偶数和${0}while(~$n=$argn[$i++])${$n&1}+=$n;echo abs(${1}-${0});
Titus

@Titus nice我认为`for(;〜$ n = $ argn [$ i ++];)$ {eo [$ n&1]} + = $ n; echo abs($ e- $ o);`也是一个不错的变体。或者我们可以做到这一点更nathematical for(;~$n=$argn[$i++];$s+=$n)$u+=($n&1)*$n;echo abs($s-2*$u);for(;~$n=$argn[$i++];)$u+=(($n&1)-.5)*2*$n;echo abs($u);是一个有趣的方式
约尔格Hülsermann

2

Haskell47 42 39 38 26 25字节

-1感谢nimi

-12感谢布鲁斯

-1感谢xnor

abs.sum.map(\x->x*(-1)^x)

在线尝试!


1
您可以内联s((*)=<<((-1)^))
nimi

1
只写要短一个字节(\x->x*(-1)^x)
xnor

1

Perl 6,28个字节

{abs sum $_ Z*.map(*%2*2-1)}

在线尝试!

将数字列表作为输入。

  • $_ 是输入参数。
  • .map(* % 2 * 2 - 1)将每个数字分别映射为1-1取决于数字是奇数还是偶数。
  • Z* 使用乘法将原始数字列表与偶数/奇数列表进行压缩。

1

Braingolf,18个字节

{.2%?M|}&+v&+c-!s*

在线尝试!

将输入作为数字列表

说明

{.2%?M|}&+v&+c-!s*  Implicit input from commandline args
{......}            Foreach loop, runs on each item in the stack..
 .2%                ..Parity check, push 1 if odd, 0 if even
    ?               ..If last item != 0 (pops last item)..
     M              ....Move last item to next stack
      |             ..Endif
        &+          Sum entire stack
          v&+       Switch to next stack and sum entire stack
             c-     Collapse into stack1 and subtract
               !s   Sign check, push 1 if last item is positive, -1 if last item is
                    negative, 0 if last item is 0
                 *  Multiply last item by sign, gets absolute value
                    Implicit output

1

R,72 43字节

b=(d=scan())%%2<1;abs(sum(d[b])-sum(d[!b]))

首先,d = scan()将数字作为输入,一个数字接一个数字输入(由于@Giuseppe注释!),
然后根据数字的奇偶校验将每个索引的a 或value b = d %% 2 <1关联。因此,数值为偶数,并且是为奇数值。bTRUEFALSEbTRUE!bTRUE

最后,abs(sum(d[b]) - sum(d[!b]))完成工作。


<1比短1个字节==0,但请注意,您也可以将输入作为数字列表。
朱塞佩

@Giuseppe好发现!谢谢 !
弗雷德里克



1

C#,67个字节

namespace System.Linq{a=>Math.Abs(a.Sum(n=>n%2<1)-a.Sum(n=>n%2>1))}

1

05AB1E,7个字节

È2*<*OÄ

在线尝试!

        # Input              | 1234567
È       # Is Even?           | [0,1,0,1,0,1,0]
 2*<    # (a * 2) - 1        | [-1,1,-1,1,-1,1,-1]
    *   # Multiply w/ input. | [-1,2,-3,4,-5,6,-7]
     O  # Sum.               | -10
      Ä # Absolute value of. | 10

1

x86-64机器码,30字节

31 C0 99 8B 4C B7 FC F6 C1 01 74 04 01 CA EB 02 01 C8 FF CE 75 ED 29 D0 99 31 D0 29 D0 C3

上面的代码定义了一个函数,该函数接受整数位的列表/数组,并返回其偶数位之和与奇数位之和之间的绝对差。

如在C,汇编语言不会将列表或数组实现为一类类型,而是将它们表示为指针和长度的组合。因此,我为该函数安排了两个参数:第一个是指向数字列表开头的指针,第二个是指定列表总长度的整数(数字总数,一个索引) 。

该函数符合System V AMD64调用约定,该约定在Gnu / UNIX系统上是标准的。特别是,第一个参数(指向列表开头的指针)被传入RDI(因为这是64位代码,它是64位指针),第二个参数(列表的长度)被传入ESI(这仅是一个32位的值,因为该位数足以使用,并且自然地假定为非零)。结果返回到EAX寄存器中。

如果更清楚,那就是C原型(您可以使用它来从C调用函数):

int OddsAndEvens(int *ptrDigits, int length);

非高尔夫装配助记符:

; parameter 1 (RDI) == pointer to list of integer digits
; parameter 2 (ESI) == number of integer digits in list (assumes non-zero, of course)
OddsAndEvens:
   xor  eax, eax              ; EAX = 0 (accumulator for evens)
   cdq                        ; EDX = 0 (accumulator for odds)
.IterateDigits:
   mov  ecx, [rdi+rsi*4-4]    ; load next digit from list
   test cl, 1                 ; test last bit to see if even or odd
   jz   .IsEven               ; jump if last bit == 0 (even)
.IsOdd:                       ; fall through if last bit != 0 (odd)
   add  edx, ecx              ; add value to odds accumulator
   jmp  .Continue             ; keep looping
.IsEven:
   add  eax, ecx              ; add value to evens accumulator
.Continue:                    ; fall through
   dec  esi                   ; decrement count of digits in list
   jnz  .IterateDigits        ; keep looping as long as there are digits left

   sub  eax, edx              ; subtract odds accumulator from evens accumulator

   ; abs
   cdq                        ; sign-extend EAX into EDX
   xor  eax, edx              ; XOR sign bit in with the number
   sub  eax, edx              ; subtract sign bit

   ret                        ; return with final result in EAX

以下是代码的简要介绍:

  • 首先,我们将EAXEDX寄存器清零,这将用于保存偶数和奇数位的总和。该EAX寄存器由清除XOR与其自身(2个字节)坏它,然后将EDX寄存器由EAX进去(符号扩展清零CDQ,1个字节)。
  • 然后,我们进入循环遍历数组中传递的所有数字的循环。它检索一个数字,测试一下它是偶数还是奇数(通过测试最低有效位,如果该值是偶数则为0,如果它是奇数则为1),然后相应地跳过或掉入,值到适当的累加器。在循环的底部,我们递减数字计数器(ESI)并继续循环,只要它不为零(即,只要列表中还有更多数字要检索)。

    唯一棘手的是初始的MOV指令,该指令使用x86上可能的最复杂的寻址模式。*它以RDI基址寄存器(指向列表开头的指针)为基数RSI(将长度索引用作索引)乘以4(整数大小,以字节为单位),并将其加到基数上,然后然后从总数中减去4(因为长度计数器是基于1的,而我们需要将偏移量设为基于0的)。这给出了数组中数字的地址,然后将其加载到ECX寄存器中。

  • 循环结束后,我们从偶数(EAX -= EDX)中减去几率。

  • 最后,我们使用一个通用技巧来计算绝对值-大多数C编译器都使用该技巧abs。我不会在这里详细介绍这种技巧的工作方式。查看代码注释以获取提示,或进行网络搜索。

__
*可以重写代码以使用更简单的寻址模式,但是并不能使其更短。我能够提出一个替代实现,该实现RDI每次取消引用并在循环中将其递增8,但是由于您仍必须递减in中的计数器ESI,因此原来是30字节。最初给我的希望是add eax, DWORD PTR [rdi]只有2个字节,与将两个注册值相加相同。这就是该实现,如果只是为了节省尝试使我付出更多努力的任何人:-)

                    OddsAndEvens_Alt:
31 C0                   xor    eax, eax
99                      cdq
                    .IterateDigits:
F6 07 01                test   BYTE PTR [rdi], 1
74 04                   je     .IsEven
                    .IsOdd:
03 17                   add    edx, DWORD PTR [rdi]
EB 02                   jmp    .Continue
                    .IsEven:
03 07                   add    eax, DWORD PTR [rdi]
                    .Continue:
48 83 C7 08             add    rdi, 8
FF CE                   dec    esi
75 ED                   jne    .IterateDigits
29 D0                   sub    eax, edx
99                      cdq
31 D0                   xor    eax, edx
29 D0                   sub    eax, edx
C3                      ret


1

TI-BASIC,11 6字节

abs(sum(Anscos(πAns

将输入作为列表。因为不需要括号i²^Ans(-1)^Ans所以节省了两个字节。

abs(sum(Anscos(πAns
           cos(πAns                  1 for evens, -1 for odds
        Ans                          Multiply by original list
abs(sum(                             Sum the list and take absolute value, which also
                                     fixes rounding errors from cos(.

1

J,14个字节

|-/(2&|+//.[),

在线尝试!

说明

|                absolute value of
 -/              the difference between
                 the items on the list returned by this fork
   (2&|          is an item odd? (1 for yes, 0 for no)
       +//.      the "key" verb /. which partitions on above (even / odd) then sums
           [)    identity, ie, the list of digits passed
             ,   turn it into a list (to handle 1 element case)
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.