The task was to convert a number to the size units without using the built-in multipliers. Thank you all for taking the time to participate in this teaser.

Now, let’s present the solution we had in mind. Starting with PowerShell 3.0, we now have two new bitwise arithmetic operators: shift-left (*shl*) and shift-right (*shr*). You can read more about them in the about_Comparison_Operators help topic.

The solution to this teaser is using the *shift-right* operator to convert the value of given number (representing a value in bytes).

Generally speaking, shifting right a number divides it by 2 and rounds the number down. Each division takes the result of the last operation and divides it again by 2.

PS> 100 -shr 1 50 PS> 100 -shr 2 25 PS> 100 -shr 3 12

Now, let’s take the value of 1KB: 1024. To get to 1024 we need to raise 2 in the power of 10. For 1MB (1048576), we need to raise it in the power of 20. 30 for *1GB*, 40 for *1PB* and so on and so forth.

PS> [math]::Pow(2,10) 1024 PS> [math]::Pow(2,20) 1048576 PS> [math]::Pow(2,30) 1073741824

We can use the values 10, 20, 30… and shift-right by them to get the corresponding unit sizes in *KB, MB, GB…*. We will use the value of 13947906293.76 (that’s 12.99GB, actually).

$value = 13947906293.76 # get the value in KB PS> $value -shr 10 13621002 # get the value in MB PS> $value -shr 20 13301 # get the value in GB PS> $value -shr 30 12

If you happen to manage Exchange 2007/2010 you are probably familiar with the size formatting *ToKB/ToMB/ToGB/ToTB* methods. Actually I owe the idea for this teaser to the Exchange team–they calculate the requested size by shifting right the value.

The formatting methods are available on *ByteQuantifiedSize *objects (*[Microsoft.Exchange.Data.ByteQuantifiedSize]*).

Here’s a list of *ByteQuantifiedSize* properties of a Mailbox object:

(Get-Mailbox shay).PSObject.Properties | Where-Object {$_.TypeNameOfValue -like "*ByteQuantifiedSize*"} | Format-Table name Name ---- ProhibitSendQuota ProhibitSendReceiveQuota RecoverableItemsQuota RecoverableItemsWarningQuota IssueWarningQuota RulesQuota ArchiveQuota ArchiveWarningQuota MaxSendSize MaxReceiveSize

To format the size of *ByteQuantifiedSize* property, you refer to its *Value* property and then to one of the above methods:

PS> $mbx.ArchiveQuota IsUnlimited Value ----------- ----- False 50 GB (53,687,091,200 bytes) PS> $mbx.ArchiveQuota.Value | Get-Member TypeName: Microsoft.Exchange.Data.ByteQuantifiedSize Name MemberType Definition ---- ---------- ---------- CompareTo Method int CompareTo(Microsoft.Exchange.Data.ByteQuantifiedSize other), int IComparable.CompareTo(... Equals Method bool Equals(System.Object obj), bool Equals(Microsoft.Exchange.Data.ByteQuantifiedSize other) GetHashCode Method int GetHashCode() GetType Method type GetType() RoundUpToUnit Method uint64 RoundUpToUnit(Microsoft.Exchange.Data.ByteQuantifiedSize+Quantifier quantifier) ToBytes Method uint64 ToBytes() ToGB Method uint64 ToGB() ToKB Method uint64 ToKB() ToMB Method uint64 ToMB() ToString Method string ToString(), string ToString(string format), string ToString(string format, System.IF... ToTB Method uint64 ToTB() PS> $mbx.ArchiveQuota.Value.ToGB() 50

Now to the prize. Congratulations **Jaap Brasser and Rob Campbell**, you get to take with you a copy of the Windows Server 2012 Automation with PowerShell Cookbook eBook. We would like to thank again Packt Publishing for the eBooks.

Jaap and Rob, in the best commmunity spirit, came up with the solution that was the shortest one that returns the right results for all five supported unit sizes:

PS> $s = 12345678964561111 PS> 1..5|%{[long](($s/=1024)-.5)} 12056327113829 11773756947 11497809 11228 10

Let’s rewrite our solution in the same manner:

PS> 1..5|%{$s -shr 10*$_}

Amazingly, we can even remove all spaces, and it’ll still work:

PS> 1..5|%{$s-shr10*$_}

See you in the next brainteaser. 🙂

Thanks for organizing the brainteaser! Also nice idea Rob using the -.5 instead of Math::Floor.

It was fun! Always enjoy a good puzzle, and the different ways people find to solve them.