Set right-adjacent bits: Difference between revisions

Line 53:

=={{header|Ada}}==

<~~lang~~ ~~Ada~~>with Ada.Text_IO;

<syntaxhighlight lang="ada">with Ada.Text_IO;

procedure Set_Right_Bits is

Line 127:

Show ("010000000000100000000010000000010000000100000010000010000100010010", 2);

Show ("010000000000100000000010000000010000000100000010000010000100010010", 3);

end Set_Right_Bits;</~~lang~~>

end Set_Right_Bits;</syntaxhighlight>

<pre>

Line 164:

=={{header|AutoHotkey}}==

<~~lang~~ ~~AutoHotkey~~>setRight(num, n){

<syntaxhighlight lang="autohotkey">setRight(num, n){

x := StrSplit(num)

for i, v in StrSplit(num)

Line 175:

res .= v

return res

}</~~lang~~>

}</syntaxhighlight>

Examples:<~~lang~~ ~~AutoHotkey~~>test1 := [

Examples:<syntaxhighlight lang="autohotkey">test1 := [

(join,

"1000"

Line 199:

MsgBox % result

return</~~lang~~>

return</syntaxhighlight>

<pre>n=2; Width e = 4:

Line 234:

=={{header|F_Sharp|F#}}==

<~~lang~~ fsharp>

// Set right-adjacent bits. Nigel Galloway: December 21st., 2021

let fN g l=let rec fG n g=[|match n,g with ('0'::t,0)->yield '0'; yield! fG t 0

Line 243:

[("1000",2);("0100",2);("0010",2);("0001",2);("0000",2);("010000000000100000000010000000010000000100000010000010000100010010",0);("010000000000100000000010000000010000000100000010000010000100010010",1);("010000000000100000000010000000010000000100000010000010000100010010",2);("010000000000100000000010000000010000000100000010000010000100010010",3)]|>List.iter(fun(n,g)->printfn "%s\n%s" n (fN n g))

</syntaxhighlight>

</lang>

<pre>

Line 268:

=={{header|Factor}}==

<~~lang~~ factor>USING: formatting io kernel math math.parser math.ranges

<syntaxhighlight lang="factor">USING: formatting io kernel math math.parser math.ranges

sequences ;

Line 279:

{ 0b1000 0b0100 0b0010 0b0000 } [ 2 4 show nl ] each

0x10020080404082112 4 <iota> [ 66 show nl ] with each</~~lang~~>

0x10020080404082112 4 <iota> [ 66 show nl ] with each</syntaxhighlight>

<pre>

Line 317:

=={{header|Go}}==

<~~lang~~ go>package main

<syntaxhighlight lang="go">package main

import (

Line 371:

fmt.Println(" Result :", sb.String())

}

}</~~lang~~>

}</syntaxhighlight>

Line 405:

Implementation:

<~~lang~~ J>smearright=: {{ +./ (-i.1+x) |.!.0"0 1/ y }}</~~lang~~>

<syntaxhighlight lang="j">smearright=: {{ +./ (-i.1+x) |.!.0"0 1/ y }}</syntaxhighlight>

Here, we use J's bit array structure, so <tt>e</tt> is implicit in the length of the list.

Line 411:

Task examples:

<~~lang~~ J>b=: '1'&= :.(' '-.~":)

<syntaxhighlight lang="j">b=: '1'&= :.(' '-.~":)

task=: {{y,:x&smearright&.:b y}}

Line 425:

3 task '010000000000100000000010000000010000000100000010000010000100010010'

010000000000100000000010000000010000000100000010000010000100010010

011110000000111100000011110000011110000111100011110011110111111111</~~lang~~>

011110000000111100000011110000011110000111100011110011110111111111</syntaxhighlight>

<code>b</code> converts from character list to bit list (and its obverse converts back to character list, for easy viewing).

Line 431:

=={{header|Julia}}==

<~~lang~~ julia>function setrightadj(s, n)

<syntaxhighlight lang="julia">function setrightadj(s, n)

if n < 1

return s

Line 454:

@show setrightadj("010000000000100000000010000000010000000100000010000010000100010010", 2)

@show setrightadj("010000000000100000000010000000010000000100000010000010000100010010", 3)

</~~lang~~>{{out}}

</syntaxhighlight>{{out}}

<pre>

setrightadj("1000", 2) = "1110"

Line 471:

=={{header|Mathematica}}/{{header|Wolfram Language}}==

<~~lang~~ ~~Mathematica~~>ClearAll[ShowSetRightBits]

<syntaxhighlight lang="mathematica">ClearAll[ShowSetRightBits]

ShowSetRightBits[b_String,n_Integer]:=Module[{poss,chars},

chars=Characters[b];

Line 485:

ShowSetRightBits["010000000000100000000010000000010000000100000010000010000100010010",1]

ShowSetRightBits["010000000000100000000010000000010000000100000010000010000100010010",2]

ShowSetRightBits["010000000000100000000010000000010000000100000010000010000100010010",3]</~~lang~~>

ShowSetRightBits["010000000000100000000010000000010000000100000010000010000100010010",3]</syntaxhighlight>

<pre>In : 1000

Line 512:

=={{header|Perl}}==

<~~lang~~ perl>#!/usr/bin/perl

<syntaxhighlight lang="perl">#!/usr/bin/perl

use strict; # https://rosettacode.org/wiki/Set_right-adjacent_bits

Line 534:

1 010000000000100000000010000000010000000100000010000010000100010010

2 010000000000100000000010000000010000000100000010000010000100010010

3 010000000000100000000010000000010000000100000010000010000100010010</~~lang~~>

3 010000000000100000000010000000010000000100000010000010000100010010</syntaxhighlight>

<pre>

Line 575:

Note that both the string and mpz versions propagate any number of bits in a single pass, in other words explicitly iterating down all the input bits as opposed to implicitly setting all those bits n times, albeit the latter is probably a smidge faster.

===string===

with javascript_semantics

function str_srb(string input, integer n)

Line 603:

end for

<pre>

Line 623:

===mpz===

identical output

with javascript_semantics

include mpfr.e

Line 649:

--...

printf(1,"n = %d: %s\n",{n,mpz_srb(input,n)})

===hybrid===

Makes it even simpler, again identical output

with javascript_semantics

include mpfr.e

Line 673:

--...

printf(1,"n = %d: %s\n",{n,mpz_srb(input,n)})

=={{header|Python}}==

Line 680:

The <code>set_right_adjacent_bits</code> function does all the real work.

<~~lang~~ python>from operator import or_

<syntaxhighlight lang="python">from operator import or_

from functools import reduce

Line 715:

result = set_right_adjacent_bits(n, b)

print(f" Input b: {b:0{e}b}")

print(f" Result: {result:0{e}b}\n")</~~lang~~>

print(f" Result: {result:0{e}b}\n")</syntaxhighlight>

Line 761:

The <code>set_right_adjacent_bits_list</code> function does all the real work.

<~~lang~~ python>from typing import List

<syntaxhighlight lang="python">from typing import List

Line 806:

result = set_right_adjacent_bits_list(n, b)

print(f" Input b: {_list2bin(b)}")

print(f" Result: {_list2bin(result)}\n")</~~lang~~>

print(f" Result: {_list2bin(result)}\n")</syntaxhighlight>

Line 851:

A left-to-right ordered collection of bits is more commonly referred to as an Integer in Raku.

<lang ~~perl6~~>sub rab (Int $n, Int $b = 1) {

<syntaxhighlight lang="raku" line>sub rab (Int $n, Int $b = 1) {

my $m = $n;

$m +|= ($n +> $_) for ^ $b+1;

Line 877:

.say for ^$bits .map: -> $b { $integer.&lab($b).fmt("%{0~$bits+$integer.msb}b") };

}</~~lang~~>

}</syntaxhighlight>

<pre>Powers of 2 ≤ 8, 0 - Right-adjacent-bits: 2

Line 947:

=={{header|Rust}}==

<~~lang~~ rust>use std::ops::{BitOrAssign, Shr};

<syntaxhighlight lang="rust">use std::ops::{BitOrAssign, Shr};

fn set_right_adjacent_bits<E: Clone + BitOrAssign + Shr<usize, Output = E>>(b: &mut E, n: usize) {

Line 995:

0b010000000000100000000010000000010000000100000010000010000100010010,

0b011110000000111100000011110000011110000111100011110011110111111111,

);</~~lang~~>

);</syntaxhighlight>

<pre>

Line 1,026:

=={{header|Wren}}==

Using a list of 0's and 1's so we don't have to resort to BigInt.

<~~lang~~ ecmascript>var setRightBits = Fn.new { |bits, e, n|

<syntaxhighlight lang="ecmascript">var setRightBits = Fn.new { |bits, e, n|

if (e == 0 || n <= 0) return bits

var bits2 = bits.toList

Line 1,053:

bits = setRightBits.call(bits, e, n)

System.print(" Result: %(bits.join())\n")

}</~~lang~~>

}</syntaxhighlight>