Codegolf - Pascals Triangle

[Michael Ulm]

My take on the latest problem from http://www.codegolf.com

a=[]
34.times{k=0;puts (a.map!{|i|k+k=i}<<1).join(" ")}

56 bytes.

Best regards,

Michael

--
Michael Ulm
R&D Team
ISIS Information Systems Austria
tel: +43 2236 27551-219, fax: +43 2236 21081
e-mail: micha...@isis-papyrus.com
Visit our Website: www.isis-papyrus.com

---------------------------------------------------------------
This e-mail is only intended for the recipient and not legally
binding. Unauthorised use, publication, reproduction or
disclosure of the content of this e-mail is not permitted.
This email has been checked for known viruses, but ISIS accepts
no responsibility for malicious or inappropriate content.
---------------------------------------------------------------

[ben...@fysh.org]

> My take on the latest problem from http://www.codegolf.com
>
> a=[]
> 34.times{k=0;puts (a.map!{|i|k+k=i}<<1).join(" ")}

:) That's very impressive - I like the way you've implemented the filter
like box kernel (summing adjacent array entries) - I wouldn't have
imagined the k=i would bind tighter than the k+k.

[Kev Jackson]

how about

a=[]
34.times{k=0;p (a.map!{|i|k+k=i}<<1).join(" ")}

I *never* use puts, and in this case using p saves you 3 characters -
yay for micro-tuning :)

Kev

--
"That government is best which governs not at all" - Henry Thoreau

[Harold Hausman]

On 8/11/06, Kev Jackson <foam...@gmail.com> wrote:
>
> On 11 Aug 2006, at 15:58, ben...@fysh.org wrote:
>
> >> My take on the latest problem from http://www.codegolf.com
> >>
> >> a=[]
> >> 34.times{k=0;puts (a.map!{|i|k+k=i}<<1).join(" ")}
> >
> > :) That's very impressive - I like the way you've implemented the
> > filter
> > like box kernel (summing adjacent array entries) - I wouldn't have
> > imagined the k=i would bind tighter than the k+k.
>
> how about
>
> a=[]
> 34.times{k=0;p (a.map!{|i|k+k=i}<<1).join(" ")}
>
> I *never* use puts, and in this case using p saves you 3 characters -
> yay for micro-tuning :)
>
> Kev
>

Unfortunately, the p method puts things in "" on stdout, which would
cause your code to fail the acceptance test. :(

-Harold

[Michael Ulm]

Kev Jackson wrote:

>
> On 11 Aug 2006, at 15:58, ben...@fysh.org wrote:
>
>>> My take on the latest problem from http://www.codegolf.com
>>>
>>> a=[]
>>> 34.times{k=0;puts (a.map!{|i|k+k=i}<<1).join(" ")}
>>
>>
>> :) That's very impressive - I like the way you've implemented the filter
>> like box kernel (summing adjacent array entries) - I wouldn't have
>> imagined the k=i would bind tighter than the k+k.
>
>
> how about
>
> a=[]
> 34.times{k=0;p (a.map!{|i|k+k=i}<<1).join(" ")}
>
> I *never* use puts, and in this case using p saves you 3 characters -
> yay for micro-tuning :)
>

This does not produce the same output on my system;
your version gives lines like

"1 2 1"

instead of

1 2 1

Since the output format is fixed in codegolf.com, unfortunately
this is not a solution.

[Sander Land]

You can make it even shorter by using *' ' over .join(' '), Array#*
is an alias for Array#join :)

[Christian Neukirchen]

Michael Ulm <micha...@isis-papyrus.com> writes:

> a=[]
> 34.times{k=0;puts (a.map!{|i|k+k=i}<<1).join(" ")}

a=[]
34.times{k=0;puts (a.map!{|i|k+k=i}<<1)*" "}

--
Christian Neukirchen <chneuk...@gmail.com> http://chneukirchen.org

[Carlos]

Christian Neukirchen wrote:
> Michael Ulm <micha...@isis-papyrus.com> writes:
>
>
>>a=[]
>>34.times{k=0;puts (a.map!{|i|k+k=i}<<1).join(" ")}
>
>
> a=[]
> 34.times{k=0;puts (a.map!{|i|k+k=i}<<1)*" "}

Let's reuse a not needed array and save 4 bytes :) (doesn't work if you
set RUBY_OPT to always require some module...)

34.times{k=0;puts ($".map!{|i|k+k=i}<<1)*" "}

--

[ben...@fysh.org]

> Michael Ulm <micha...@isis-papyrus.com> writes:
>
>> a=[]
>> 34.times{k=0;puts (a.map!{|i|k+k=i}<<1).join(" ")}
>
> a=[]
> 34.times{k=0;puts (a.map!{|i|k+k=i}<<1)*" "}

a=[]
9.times{k=0;puts (a.map!{|i|k+k=i}<<1)*" "}

:)

[Daniel Martin]

Michael Ulm <micha...@isis-papyrus.com> writes:

> My take on the latest problem from http://www.codegolf.com
>
> a=[]
> 34.times{k=0;puts (a.map!{|i|k+k=i}<<1).join(" ")}
>
>
> 56 bytes.

I think this may be very close to minimal - no approaches I tried got
this small. Note that you can slightly improve readability (but with
no change in character count) with:

a=[]
34.times{k=0;a.map!{|i|k+k=i}<<1;puts a.join(" ")}

Then there's removing the parentheses around the argument to join, but
that generates a warning that probably means you fail their test.

[Dale Martenson]

How about:

a=[]
34.times{k=0;puts (a.map!{|i|k+k=i}<<1)*' '}

--
Posted with http://DevLists.com. Sign up and save your mailbox.

[Ben Bleything]

On Fri, Aug 11, 2006, Carlos wrote:
> Let's reuse a not needed array and save 4 bytes :) (doesn't work if you
> set RUBY_OPT to always require some module...)
>
> 34.times{k=0;puts ($".map!{|i|k+k=i}<<1)*" "}

This doesn't work:

>> 34.times{k=0;puts ($".map!{|i|k+k=i}<<1)*' '}
TypeError: String can't be coerced into Fixnum
from (irb):1:in `+'
from (irb):1
from (irb):1
from (irb):1
from :0

However, changing $" to $* works like a champ :)

34.times{k=0;puts ($*.map!{|i|k+k=i}<<1)*' '}

Ben

[Thomas, Mark - BLS CTR]

> However, changing $" to $* works like a champ :)
>
> 34.times{k=0;puts ($*.map!{|i|k+k=i}<<1)*' '}
>
> Ben
>

Now at 45 chars it ties the current leader.

[Carlos]

Ben Bleything wrote:

> On Fri, Aug 11, 2006, Carlos wrote:
>
>>Let's reuse a not needed array and save 4 bytes :) (doesn't work if you
>>set RUBY_OPT to always require some module...)
>>
>> 34.times{k=0;puts ($".map!{|i|k+k=i}<<1)*" "}
>
>
> This doesn't work:

See caveat about environment variables, above.

>>>34.times{k=0;puts ($".map!{|i|k+k=i}<<1)*' '}
>
> TypeError: String can't be coerced into Fixnum
> from (irb):1:in `+'
> from (irb):1
> from (irb):1
> from (irb):1
> from :0
>
> However, changing $" to $* works like a champ :)
>
> 34.times{k=0;puts ($*.map!{|i|k+k=i}<<1)*' '}

Much better choice, yes.
--