Pushing items in the sequence

Question

Aim

If you are given a sequence such as (A, G, M, _, _, C, D, _, G) your aim is to push all non empty elements to one side to get (A, G, M, C, D, G, _, _, _). You must preserve the order of the non-empty elements.

Rules

1. You are free to choose the sequence type. (strings, numbers, containers etc). You must also choose a Nil/None/Null character or element that will fit your sequence type. eg; spaces or underscores inside a string.
2. User should be able to input the push direction (left or right) and the sequence. Input values and format are up to you to choose. eg; Your code handles sequences that are numbers with 7 as the null character. You set R for right, L for left. So user inputs R, 1577462722727777. The result is 7777777715462222
3. Rearranged sequence should be displayed or written to a file.
4. Your code should not exceed 128 bytes.

Points

1. +(10 / bytes) golfing points
2. +1 for Moses-Mode. Push half the elements to the left, and half to the right. If odd number of items are present, you may choose the direction of the final element. eg; (A, G, M, _, _, _, C, D, G)

You may use use this calculator to round your points to the hundredth decimal place.

Answer 1

R - 10 / 71 70 66 39 bytes = 0.26 points

Saved 27 bytes thanks to Mickey!

function(d,s)s[order(xor(!is.na(s),d))]

This creates an unnamed function which takes a direction d (logical with TRUE corresponding to right and FALSE to left (legit per OP's comment)) and a vector s (assumed to use NA for empty elements) as input and returns a vector. To call it, give it a name, e.g. f=function(d,s)....

This does not support "Moses Mode."

Ungolfed + explanation:

f <- function(d, s) {
    # Order the elements of s by non-missing exclusive or direction
    s[order(xor(!is.na(s), d))]
}

Examples:

> test <- c(1, 5, NA, NA, 4, 6, 2, NA, 2, 2, NA, 2, NA, NA, NA, NA)
> f(FALSE, test)
[1] NA NA NA NA NA NA NA NA  1  5  4  6  2  2  2  2
> f(TRUE, test)
[1]  1  5  4  6  2  2  2  2 NA NA NA NA NA NA NA NA

And an extra special example just for FryAmTheEggman:

> c(f(TRUE, test), "BATMAN")
[1] "1" "5" "4" "6" "2" "2" "2" "2" NA NA NA NA NA NA NA NA "BATMAN"

Answer 2

Haskell 10/24 bytes = 0.42 points

import Data.List
(.sort)

Sadly the sort function is in Data.List, so I have to import it.

The sequence type is boolean values, i.e. True or False. The empty value is False. Pushing non empty values to the right is indicated by id and to the left by reverse.

Example usage:

*Main> (.sort) id [True,False,False,True,False,True]
[False,False,False,True,True,True]
*Main> (.sort) reverse [True,False,False,True,False,True]
[True,True,True,False,False,False]

Answer 3

Pyth, 10 / 15 14 bytes + 1 = 1.71 points

[email protected]@dzQ

This takes two lines of input. The first one is a string (spaces are the special characters) and the second one is 0 (push all spaces to the right), 1 (Moses-mode) or 4 (push all spaces to the left).

Try it online: Demonstration

Thanks to @isaacg for saving one byte

Explanation:

                 implicit: z = input string, Q = input number
       -zd       remove all spaces from z
     c2          split into 2 equal pieces
    a            append
          @dz    get all spaces in z
  .p             create all permutation of the 3 strings
 @           Q   choose the Qth permutation
s                and join the strings       

Pyth, 10 / 7 bytes = 1.43 points

oqQqNdz

Input format: string on first line, and 0 (push spaces to the left) or 1 (push spaces to the right) on second line.

Try it online: Demonstration

This is worth less points, but it's a quite simple and elegant solution.

Explanation:

          implicit: z = input string, Q = input number
o     z   order the chars N of z by the key:
 qQqNd       Q == (N == " ")

When Q == 0 all spaces get the key 0 and all other chars get the key 1, otherwise it's exactly opposite. Then the string is sorted by their keys. Since sorting is stable in Pyth, it sorts all spaces either to the beginning or the end and keeps all other chars in the same order.

Answer 4

I honestly don't mind that the challenge has a byte limit. It is the OP's choice to impose that restriction to make things more interesting. However, just to represent how a "wordy" language would do, here's java:

Java

283 bytes = 0.04points + 1 = 1.04

enum E{;public static void main(String[]r){String s="",t=r[0].substring(1),d="_";char p=r[0].charAt(0);for(;t.indexOf(d)>=0;){r=t.split(d,2);t=r[0]+r[1];s+=d;}int x=(t.length()-1)/2;if(p=='L')t+=s;else if(p=='R')t=s+t;else t=t.substring(0,x)+s+t.substring(x+1);System.out.print(t);}}

Input is from the command line. The first character can be L for left, R for right, anything else for moses mode. Underscore is used for the null character.

If I remove the moses mode code, I get:

207 bytes = 0.05points

enum E{;public static void main(String[]r){String s="",t=r[0].substring(1),d="_";char p=r[0].charAt(0);for(;t.indexOf(d)>=0;){r=t.split(d,2);t=r[0]+r[1];s+=d;}if(p=='L')t+=s;else t=s+t;System.out.print(t);}}

Input is from the command line. L is left, anything else is right. Underscore is null.

I quite enjoyed the challenge of trying to fit Java code inside 128 bytes. Java just isn't a competitive language for codegolfs though.

Answer 5

k,10/12 = 0.83 points

{x((>:;<:)y)x}

It takes an array of booleans and a 0 or 1 to say to push to the right or the left.

k){x((>:;<:)y)x}[1011110101101b;0]
1111111110000b
k){x((>:;<:)y)x}[1011110101101b;1]
0000111111111b

k, 10/29 = 0.34 points

A more flexible version that should work for all input types and which allows you to choose the null character.

{x@,/$[~z;|:;](&~:;&:)@\:x=y}

.

k){x@,/$[~z;|:;](&~:;&:)@\:x=y}[1 0 3 6 5 6 0 6 0;6;0]
6 6 6 1 0 3 5 0 0
k){x@,/$[~z;|:;](&~:;&:)@\:x=y}[1 0 3 6 5 6 0 6 0;6;1]
1 0 3 5 0 0 6 6 6
k){x@,/$[~z;|:;](&~:;&:)@\:x=y}[1 0 3 6 5 6 0 6 0;0;1]
1 3 6 5 6 6 0 0 0
k){x@,/$[~z;|:;](&~:;&:)@\:x=y}["abc def ghi";" ";1]
"abcdefghi  "
k){x@,/$[~z;|:;](&~:;&:)@\:x=y}["abc def ghi";" ";0]
"  abcdefghi"

Answer 6

Pyth - 10 / 1 byte + 1 = 11

Really cheaty, but it seems allowed, basically puts all the code in the options. Doing bonus now.

It takes an array of ints, with 0 as falsey.

The left value is: Y.append(eval(input())) or [i for i in Y[0] if i] + [0]*Y[0].count(0)

The right value is: Y.append(eval(input())) or [0]*Y[0].count(0) + [i for i in Y[0] if i]

The Moses value is: Y.append(eval(input())) or Y.append(chop(2, [i for i in Y[0] if i])) or Y[1][0] + [0]*Y[0].count(0) + Y[1][1]

So here is the code:

Q

Because of security reasons it only works locally, not online.

Old, non-cheaty one - 0.83:

Not going for the bonus, takes array of ints, 0 is falsey, and 1 for right, -1 for left.

Ms%H,fTGf!TG

Explanation coming soon.

M           Two var lambda
 s          Join the two parts of the array
  %         String slice step, reverses if -1, unchanged if 1
   H        Second arg
   ,        Two element list
    fTG     Filter arg 1 for truthiness
    f!TG    Filter arg 1 for falsiness

Try it here online.

Answer 7

R 10 / 69 + 1 = 1.14

Not very pretty. An unnamed function where d is a either 0 (left), 1 (right) or .5 (Moses). s is a vector of integers where 0 as the null.

function(d,s)c(rep(0,(l=length(s[!s]))*(1-d)),s[!!s],rep(0,(l*d)+.5))

Test example

> g=function(d,s)c(rep(0,(l=length(s[!s]))*(1-d)),s[!!s],rep(0,(l*d)+.5))
> test=c(17,0,2,42,2,4,35,0,0,45,0,2,0,7,9)
> g(0,test)
 [1]  0  0  0  0  0 17  2 42  2  4 35 45  2  7  9
> g(1,test)
 [1] 17  2 42  2  4 35 45  2  7  9  0  0  0  0  0
> g(.5,test)
 [1]  0  0 17  2 42  2  4 35 45  2  7  9  0  0  0
> test=c(17,0,2,42,0,2,4,35,0,0,45,0,2,0,7,9)
> g(0,test)
 [1]  0  0  0  0  0  0 17  2 42  2  4 35 45  2  7  9
> g(1,test)
 [1] 17  2 42  2  4 35 45  2  7  9  0  0  0  0  0  0
> g(.5,test)
 [1]  0  0  0 17  2 42  2  4 35 45  2  7  9  0  0  0
> 

Answer 8

JavaScript (ES6) - 168 bytes, 1.06 points

x=(d,a)=>{c='concat',l='length',o=a.filter(l=>l),z=new Array(a[l]-o[l]).fill(0);if(!d)Array.prototype.splice.apply(o,[a[l]/4,0][c](z));return d?(d>1?z[c](o):o[c](z)):o}

Input:

• 0 (or any falsy value) for Moses mode, 1 for push left, 2 for push right
• Array of integers in second parameter, 0 considered empty

Unminified code

x = (mode, data) => {
    var concat = 'concat',
        length = 'length',
        stripped = data.filter(el => {
            return !!el;
        }),
        zeroes = new Array(data[length] - stripped[length]).fill(0);

    if (!mode) {
        Array.prototype.splice.apply(stripped, [data[length] / 4, 0][concat](zeroes));
    }

    return mode ? (mode > 1 ? zeroes[concat](stripped) : stripped[concat](zeroes)) : stripped;
};

Answer 9

CoffeeScript, 172 bytes = 1.06 points

x=(m,d)->c='concat';l='length';s=d.filter((el)->el);z=new Array(d[l]-s[l]).fill 0;(Array.prototype.splice.apply(s,[d[l]/4,0][c] z);return s)if!m--;return z[c] s if!m;s[c] z

First parameter is mode: 0 (or false) for Moses mode, 1 for push right (prepend), 2 for push left (append)

Second parameter is an array of integers where 0 is considered the empty token (though all falsy values are considered empty, but will be replaced with 0).

Version without Moses mode: 91 bytes = 0.11 points

x=(d,a)->o=a.filter((l)->''!=l);o[if d then'push'else'unshift'] ''while a.length-o.length;o

First parameter is a Boolean indicating whether to push right (true or any truthy value) or push left (false or any falsy value).

Second parameter is the array. Empty tokens include empty strings.

Answer 10

PHP - 176 bytes, 1.06 points

function x($m,$d){$c=count;$y=array_merge;$s=array_filter($d);$z=array_fill(0,$c($d)-$c($s),0);if(!$m)array_splice($s,$c($s)/4+1,0,$z);return!$m?$s:(--$m?$y($z,$s):$y($s,$z));}

Where $m is:

• 0: Moses mode
• 1: Append (push left)
• 2: Prepend (push right)

And $d is the an array of numeric where 0 or 0.0 is considered empty.

There are notices for undefined constants but they still work.

Answer 11

rs, 41 bytes

+(.)(\d+)_(\d+)/\1_\2\3
l(_+)(.+)/\2\1
r/

Takes input as a sequence of numbers, with l for left, r for right, and the underscore as the null character, e.g. r_3_12.

Live demo here.

Answer 12

k2, 28 bytes

{,/ :[y;|:](x@&~x=0;x@&x=0)}

I already have another answer, and there's another K answer (for k3), but I believe this one uses a vastly different approach, IMO. 0 is used as the null value. Two unfortunate issues:

1. k2 has no binary vectors.
2. #1 makes this one really long.

Usage:

{,/ :[y;|:](x@&~x=0;x@&x=0)}[1 1 0 1 2 3 0 1;1] / outputs 0 0 1 1 1 2 3 1
{,/ :[y;|:](x@&~x=0;x@&x=0)}[1 1 0 1 2 3 0 1;0] / outputs 1 1 1 2 3 1 0 0

Now, if I am allowed to use just 1 and 0 as my input, I can get much shorter, but then it ends up being almost the same thing as the other K answer. So...yeah. This sucks. :(

Answer 13

Some have mentioned above that wordy languages can't participate because of the restriction in byte count. I doubt it. Here's a python solution, and I think python is a wordy language, somewhat golfed.

Python 2.7

68 bytes, 0.15 points

62 bytes, 0.16 points (thanks to @Sp3000)

d,s=input();e=filter(None,s),[0]*s.count(0)
print e[d]+e[d+1]

input/ouput

0 for right, -1 for left, list of numbers as sequence. 0 is the null character
>>>0, [1, 0, 2, 3, 6, 0, 0, 0, 5]
[1, 2, 3, 6, 5, 0, 0, 0, 0]
>>>-1, [1, 0, 2, 3, 6, 0, 0, 0, 5]
[0, 0, 0, 0, 1, 2, 3, 6, 5]

Answer 14

Perl - 103 bytes, 1.09 points

$_=<>;s/\n//;$b='_'x s/_//g;$x=length($_)/2;print(($b.$_,$_.$b,(substr($_,0,$x).$b.substr$_,$x))[<>+0])

The sequence is a string. The null element is an underscore character. It reads the string as a line from the standard input, then reads the direction as another line: 0 for right, 1 for left, 2 for Moses mode.

Version without Moses Mode - 49 bytes, 0.20 points

$_=<>;s/\n//;$b='_'x s/_//g;print<>+0?$_.$b:$b.$_

Same as the above except shorter and without Moses mode implemented.