合并阵列


33

任务很简单:整合一个整数数组。合并此数组包括以下内容:

  • 所有0实例都需要移到数组的末尾。
  • 非零整数之间不应有0。
  • 所有非零索引都应保留其顺序。

挑战

以最少的字节数合并数组。

您正在合并一个随机长度的数组,该数组的大小最大为您的语言的最大值,并包含随机整数。输入可能是您语言的任何自然方式。

例子

输入项

0 5 8 8 3 5 1 6 8 4 0 3 7 5 6 4 4 7 5 6 7 4 4 9 1 0 5 7 9 3 0 2 2 4 3 0 4 8 7 3 1 4 7 5 1 2 1 8 7 8 7 7 2 6 3 1 2 8 5 1 4 2 0 5 0 6 0 3

输出量

5 8 8 3 5 1 6 8 4 3 7 5 6 4 4 7 5 6 7 4 4 9 1 5 7 9 3 2 2 4 3 4 8 7 3 1 4 7 5 1 2 1 8 7 8 7 7 2 6 3 1 2 8 5 1 4 2 5 6 3 0 0 0 0 0 0 0 0

输入项

-1 -7 -6 5 1 -5 -2 7 -3 -8 0 8 9 1 -8 -1 6 -4 1 -2 1 -7 5 4 -6 7 -3 9 8 3 -1 0 -5 -7 3 8 1 1 3 -3 -2 -2 0 -7 0 -4 8 6 -3 6 0 5 3 2 2 2 -2 -7 -3 9 -1 6 0 6 -7 9 4 -2 8 -8 -4 1 -8 4 3 7 3 5 1 0 3 3 7 -1 -5 1 -3 4 -7 0 3 2 -2 7 -3 0 0 2 -5 8 -3 -2 -7 -5 7 -3 -9 -7 5 8 -3 9 6 7 -2 4 7

输出量

-1 -7 -6 5 1 -5 -2 7 -3 -8 8 9 1 -8 -1 6 -4 1 -2 1 -7 5 4 -6 7 -3 9 8 3 -1 -5 -7 3 8 1 1 3 -3 -2 -2 -7 -4 8 6 -3 6 5 3 2 2 2 -2 -7 -3 9 -1 6 6 -7 9 4 -2 8 -8 -4 1 -8 4 3 7 3 5 1 3 3 7 -1 -5 1 -3 4 -7 3 2 -2 7 -3 2 -5 8 -3 -2 -7 -5 7 -3 -9 -7 5 8 -3 9 6 7 -2 4 7 0 0 0 0 0 0 0 0 0 0

示例代码(Java)

public class Consolidate {
    public static void main(String[] args) throws Exception {
        int[] toConsolidate = new int[args.length];
        for (int i=0; i<args.length; i++){
            toConsolidate[i]=Integer.parseInt(args[i]);
        }
        for (int i=0; i<toConsolidate.length; i++) {
            for (int k=0; k<toConsolidate.length-1; k++) {
                if (toConsolidate[k] == 0){
                    toConsolidate[k] = toConsolidate[k+1];
                    toConsolidate[k+1] = 0;
                }
            }
        }
        for (int i:toConsolidate)
            System.out.print(i+" ");
    }
}

有没有整数或个位数,例如示例?
edc65 '16

@ edc65您的语言支持的任何整数。
Addison Crump

当最短答案为3个字符时,示例如何如此复杂?Java那么冗长吗?
AL

7
不是“非零整数之间不应有0。” 多余的?
Martin Ender

1
@immibis可能不是此挑战的正确语言。:P
Addison Crump

Answers:


31

Pyth,3个字节

!DQ

说明:

  Q    Input
!D     Sort by logical NOT

在这里尝试。


Q可以在任何Pyth脚本的末尾隐式表示(假设它在lambda之外),使之成为2个字节。
hakr14

@ hakr14该功能2年前不存在。
丹尼斯

12

果冻,3个字节

¬Ụị

按值的逻辑非对列表进行排序。在线尝试!

怎么运行的

¬Ụị    Main link. Input: A (list)

¬      Compute the logical NOT of each element of A.
 Ụ     Grade up; sort the resulting list's indices by their corresponding values.
  ị    Retrieve the elements of A at that indices.

1
哦,嘿,现代的Jelly ¬Þ甚至可以做到2字节!
林恩


9

R,29 23 21字节

正如MarcoBreitig所述,如果不需要将其作为函数提供,则可以将其缩短为21个字节:

x=scan();x[order(!x)]

之前的版本:

function(x)x[order(!x)]

该函数将向量作为输入,并通过对输入求反得出的逻辑向量进行排序。

原始答案:

function(x)c(x[x!=0],x[x==0])

该函数将向量作为输入,然后将(0 c())非零值然后是零值连接起来。


2
x = scan(); x [order(!x)]只有21个字节长。
Marco Breitig '16

@MarcoBreitig,是的。我认为这应该是一个功能(最初,要求是“成熟的程序”)。将会更新我的答案
docendo discimus '02


7

ES6,23个字节

a=>a.sort((x,y)=>!x-!y)

过去这种情况sort不稳定,在这种情况下,您需要41个字节:

a=>a.filter(x=>x).concat(a.filter(x=>!x))

6

Python字节码(2.7.9),252个字节,33个操作码,0.0228秒

这是当比赛仍是比赛时建立的

在当前目录中打开一个文件以'SourceArray'供使用

LOAD_CONST          ''
STORE_FAST          no_zeroes#  no_zeroes = ''

LOAD_NAME           open
LOAD_CONST          'SourceArray'
CALL_FUNCTION       0,1#  open('SourceArray')
LOAD_ATTR           read
CALL_FUNCTION       0,0#  .read()

LOAD_ATTR           split
CALL_FUNCTION       0,0#  .split()

DUP_TOP
DUP_TOP             #Start if
BUILD_LIST          0
COMPARE_OP          ==
POP_JUMP_IF_TRUE    35#  if list == [], GOTO 35
LOAD_ATTR           pop
LOAD_CONST          0
CALL_FUNCTION       0,1#  list.pop(0)
DUP_TOP
LOAD_CONST          '0'
COMPARE_OP          ==
POP_JUMP_IF_TRUE    28#  if list.pop(0) == '0', GOTO 28
PRINT_ITEM          #  print list.pop(0)
JUMP_ABSOLUTE       13

POP_TOP
LOAD_CONST          '0%_'#  '0 '
LOAD_FAST           no_zeroes
INPLACE_ADD
STORE_FAST          no_zeroes#  no_zeroes = no_zeroes + '0 '
JUMP_ABSOLUTE       13

LOAD_FAST           no_zeroes
PRINT_ITEM          #  print no_zeroes

LOAD_CONST          None
RETURN_VALUE

co_code(实际的codeY位)

'd\x01\x00}\x00\x00\te\x00\x00\x83\x00\x00\tj\x01\x00\x83\x00\x00\t\x04\x04g\x00\x00k\x02\x00sG\x00j\x02\x00d\x02\x00\x83\x01\x00\x04d\x03\x00k\x02\x00s8\x00Gq\x15\x00\t\x01d\x04\x00|\x00\x007}\x00\x00q\x15\x00\t|\x00\x00G\td\x00\x00S'

或.pyc文件版本 03F3

03 F3 0D 0A 40 FD B0 56 63 00 00 00 00 01 00 00 00 03 00 00 00 00 00 00 00 73 59 00 00 00 64 01 00 7D 00 00 09 65 00 00 64 02 00 83 01 00 6A 01 00 83 00 00 09 6A 02 00 83 00 00 09 04 04 67 00 00 6B 02 00 73 50 00 6A 03 00 64 03 00 83 01 00 04 64 04 00 6B 02 00 73 41 00 47 71 1E 00 09 01 64 05 00 7C 00 00 37 7D 00 00 71 1E 00 09 7C 00 00 47 09 64 00 00 53 28 06 00 00 00 4E 74 00 00 00 00 74 0B 00 00 00 53 6F 75 72 63 65 41 72 72 61 79 69 00 00 00 00 74 01 00 00 00 30 73 02 00 00 00 30 20 28 04 00 00 00 74 04 00 00 00 6F 70 65 6E 74 04 00 00 00 72 65 61 64 74 05 00 00 00 73 70 6C 69 74 74 03 00 00 00 70 6F 70 28 01 00 00 00 74 09 00 00 00 6E 6F 5F 7A 65 72 6F 65 73 28 00 00 00 00 28 00 00 00 00 74 09 00 00 00 70 79 6B 65 5F 63 6F 64 65 52 08 00 00 00 01 00 00 00 52 00 00 00 00

您可以尝试使用github上的库自己编译我的源代码我刚刚发布了一个承诺,允许评论,所以我希望就而言,它仍在竞争;)

大致相当于

no_zeroes = ''
unamed_variable = open('SourceArray').read().split()
while unamed_variable != []:
    unamed_variable_2 = unamed_variable.pop()
    if unamed_variable_2 == '0':
        no_zeroes += '0 '
    else:
        print unamed_variable_2,
print no_zeroes,

哇 你切的时间过这一点。
Addison Crump

@VoteToClose大约是笔记本电脑上运行速度的1.5倍:O谁说Python 这么慢?
蓝色

6

Python,32字节

lambda x:sorted(x,key=0..__eq__)

将参数视为任何可迭代的变量(列表,元组等)。感谢@xnor教给我一个新技巧!


使用起来有点短key=0..__eq__(是的,两个点)。
xnor

@xnor很好...它是如何工作的?
Mego

7
大多数Python对象都有一个equal方法,例如"abc".__eq__("abc")==True。这就是你做的时候所说的"abc"==由于某些原因,Python整数没有它,而浮点数则有,并且既然如此0. == 0,我们就可以用它的相等运算符。代替0..__eq__
xnor

@xnor啊,我知道这种.__eq__方法,但是双点使我感到困惑。我没有发现第一个是浮点文字中的小数点。
Mego

6

Matlab:21个字节

@(a)[a(a~=0),a(a==0)]

首先打印非零元素,然后与零元素连接

@(a)____ 用一个输入参数创建一个匿名函数 a

[___,___] 在括号内水平连接向量,以逗号分隔

a(a~=0) 返回带有vector的所有非零元素的vector a

a(a==0) 返回vector的所有零元素的vector a


5

Haskell,26个字节

f x=filter(/=0)x++[0|0<-x]

取所有非零数字,然后取全零。0使用列表推导时,过滤常量(此处为)非常短[0|0<-x]


5

Zsh,22个字节

(输入作为参数传递给脚本/函数($@也称为$argv数组),在stdout上以空格分隔的列表输出,换行符终止)

<<<${@:#0}\ ${(M)@:#0}
  • <<< string:here-string这里作为标准输入传递给$NULLCMD命令(cat默认)。
  • ${@:#0} $@ 元素为0除外。
  • ${(M)@:#0} 上面的相反

假定(像这里的其他几个答案一样),输入中的零全部表示为0(no 00nor 0x0nor 36#0)。


4

Javascript,52 54 51字节

s=>s.replace(/\b0 /g,x=>++i&&'',i=0)+' 0'.repeat(i)

当输入不包含任何零时,此方法将不起作用
rink.attendant.6 16-02-22

@ rink.attendant.6。谢谢,我已经更新,仍在寻找一些字节:)
删除


4

APL:8个字节

(⍴a)↑a~0


a〜0 从a(读为“ a不含0”)(⍴a)的a的原始长度(读为“ a的形状”)中删除零,
将不带零的a填充为a的原始长度

http://ngn.github.com/apl/web/index.html中尝试

测试数据:a←1 0 1 2 3 4 0 1 0 0 0 0 1 2 3 4 5


1
您应该编写一个完整的程序并从stdin中读取输入,或者编写一个函数并从其参数中读取输入。但是您可以使用⍴↑{⍵~0},而且甚至更短。
jimmy23013 '16

没那么快。⍴↑{⍵〜0}不会在所有地方都可用,在APL2000和IBM APL2中都不会。
罗巴切夫斯基

⍴↑{⍵〜0}将返回一个空向量。⍴⍴↑{⍵〜0}是一个(一个元素向量)零。
罗巴切夫斯基

4

Java 7,78字节

void g(int[]a){int c=0;for(int o:a)a[o==0?c:c++]=o;for(;c<a.length;a[c++]=0);}

我不确定为什么其他Java条目使用字符串。如果要过滤整数数组,似乎最好使用整数数组。这通过保留两个索引来修改输入的位置,然后仅用零填充其余的插槽。


嘿,我用它是因为我喜欢它。我想你应该能够宣布oint c=0,o;for(o:a)...。您还可以转换为Java 8 lambda语法:a->{int c=0;for(int o:a)a[o==0?c:c++]=o;for(;c<a.length;a[c++]=0);}并声明它希望输入为int数组。
Addison Crump

等一下,抓紧o声明。但仍然是Java 8 Lambda。:D
Addison Crump

@VoteToClose我认为它必须是独立的。如果我可以在其他地方声明类型和东西而无需计算,那似乎是不对的。
Marky Markov

由于这是一个函数,因此无论如何,输入都是通过先前执行的语句传递给它的。lambda可以采用输入类型,因此其本质上相同。
Addison Crump

3

Common Lisp,46个字节

(lambda(a)(stable-sort a(lambda(_ b)(= 0 b))))

对数组进行排序,以便对于每对(a,b),如果b为零,则有一个<b。当a <bb <a都不是时,排序是稳定的:保留元素之间的原始顺序。

我也尝试过使用Adjust-arrayremove,但这太长了:

(lambda(a)(adjust-array(remove 0 a)(length a):initial-element 0))

3

PHP,73 71 70 52 49 48 46字节-非常感谢Ismael Miguel

// Assuming
$a = array(4,8,6,1,0,8,0,0,0,0,0,-4,'-5',-1,564,0);

// Produces a notice-level error
foreach($a as$v)$v?print"$v ":$b.="0 ";echo$b;

1
$v==0可以替换为!$v,为您节省2个字节。
Ismael Miguel '02

@IsmaelMiguel谢谢!
MonkeyZeus '16

别客气。我看到您确实设法削减了一个字节。试试这个:foreach($argv as$v)$v?$f.=" $v":$b.=" $v";echo$f.$b;。它是....一些字节,我不知道...
Ismael Miguel

2
或者foreach($a as$v)$v?print("$v "):$b.="$v ";echo$b;,以更简洁的方式,看起来完全一样
Ismael Miguel

1
@IsmaelMiguel尼斯!如果我不得不接管别人的项目并发现这一级别的代码
搜寻笑声,

3

Bash + GNU实用程序,23

grep -v ^0 a
grep ^0 a

假设输入是一个名为的文件中以换行符分隔的条目a。该文件名的分数包括+1。


@sch是的,应该是bash-已修复。
Digital Trauma

@TimmyD是-感谢您的提醒。
Digital Trauma

3

Perl 5,26个字节

23加3 -an-E免费)

say for sort{!$a-!$b}@F

感谢Dennis提醒我-a,节省了两个字节。


2

CJam,6个字节

{{!}$}

匿名函数。使用“元素是否为零”作为关键字进行排序。


2

MATL,7个字节

t~FT#S)

在线尝试!

t      % input array. Duplicate
~      % logical negate: nonzero values become false, zeros become true
FT#S   % sort (false, then true) and output a vector with the indices of the sorting
)      % apply that vector of indices to original array

2

认真地,12个字节

4,n`Y`M@░)░+

在线尝试!

说明:

4,n`Y`M@░)░+
4,n           push 4 copies of input
   `Y`M       map logical negate
       @░)    filter (take zeroes) and push to bottom of stack
          ░   filter (take non-zeroes)
           +  append zeroes


2

Perl6,11个字节

{.sort(!*)}

产生一个Block-可以在数组上调用:

{.sort(!*)}.([1,2,0,3]).say

尽管写起来更自然(更短):

[1,2,0,3].sort(!*).say

工作原理:如果使用仅接受一个参数的块调用perl6排序例程,则列表元素将根据进行排序by($a) cmp by($b)。在这种情况下,块是!*,即any 运算符的取反。

我注意到:

  • 问题中的示例是一个提供方法的类,其中不包括读入所需的样板
  • 该任务的描述不需要打印,并且,除了示例打印的事实外,它暗示可能会返回一个数组。

2

TeX(纯格式),160字节

使0字符处于活动状态(即,使解释器将其作为命令来处理),然后定义该命令以跳过字符并增加计数器。在字符串的末尾,打印与计数一样多的零。

将其另存为,zero.tex并使用以下命令通过命令行输入:

pdftex "\def\I{0 1 0 3 2 0 0 8 0 5 0 1 9 4}\input zero"
\def\I{}\newcount\Z\def\L{\loop\advance\Z by-1\ifnum\Z>00 \repeat}
\begingroup\catcode`\013 \def0{\advance\Z by1}
\scantokens\expandafter{\I\empty}\endgroup\L\bye

(为清楚起见添加了换行符)

在此处输入图片说明


2

J,4个字节

/:0=

说明:

/:      NB. upward sort on
  0=    NB. equality to zero

规范保证J中的排序函数稳定。

替代解决方案,6个字节:

#{.*#+

 

   *#+  NB. replicate each item by its sign (removing zeroes)
#{.     NB. take as many items from this as the original list had
        NB.  (taking more items than there are in a list results in extra zeroes)

2

稻草30 29字节

<:([^0 ])()/,0()/ +,+( +) /}>

使用CP437编码

说明

<:([^0 ])()/,0()/ +,+( +) /}>
<                             Take input
 :                            Duplicate
  ([^0 ])()/                  Remove every character that is not a 0 or a space
            ,                 Swap the two items on the top of the stack
             0()/             Remove every 0 on the top of the stack
                  +           Push a space and concatenate
                   ,          Swap
                    +         Concatenate
                     ( +) /   Remove duplicate spaces
                           }  Get the 'tail' of the string
                            > Output

在线尝试!(添加的代码用于测试所有测试用例)


2

JavaScript ES6,16个字节

x=>x.sort(t=>!t)

在Firefox上工作



1

05AB1E15 14字节

码:

ED0¢r0KR`rFZ}|

说明:

E               # Evaluate input
 D              # Duplicate top of the stack
  0¢            # Count zeroes
    r           # Reverse stack
     0K         # Delete all zeroes
       R        # Reverse top of the stack
        `       # Flatten
         r      # Reverse stack
          FZ}   # For N in range(amount zeroes): push zero
             |  # Print full stack

使用CP-1252编码。采取这样的数组:

[0, 5, 8, 8, 3, 5, 1, 6, 8, 4, 0, 3, 7, 5, 6, 4, 4, 7, 5, 6, 7, 4, 4, 9, 1, 0, 5, 7, 9, 3, 0, 2, 2, 4, 3, 0, 4, 8, 7, 3, 1, 4, 7, 5, 1, 2, 1, 8, 7, 8, 7, 7, 2, 6, 3, 1, 2, 8, 5, 1, 4, 2, 0, 5, 0, 6, 0, 3]
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.