<p>I might suggest you stick to hex or base64 instead of making your own formatting</p>

<pre><code>dat = [1, 0, 11, 0, 4, 0, 106, 211, 169, 1, 0, 12, 0, 8, 0, 1, 26, 25, 32, 189, 77, 216, 1, 0, 1, 0, 4, 0, 0, 0, 0, 12, 15]
</code></pre>

<p>Hexadecimal</p>

<pre><code>hex = dat.map { |x| sprintf('%02x', x) }.join
# =&gt; 01000b0004006ad3a901000c000800011a1920bd4dd80100010004000000000c0f
</code></pre>

<p>Base64</p>

<pre><code>require 'base64'
base64 = Base64.encode64(dat.pack('c*'))
# =&gt; AQALAAQAatOpAQAMAAgAARoZIL1N2AEAAQAEAAAAAAwP\n
</code></pre>

<hr>

<p><strong>Proquints</strong></p>

<p>What? <a href="https://arxiv.org/html/0901.4016" rel="nofollow noreferrer">Proquints</a> are pronounceable unique identifiers which makes them great for reading/communicating binary data. In your case, maybe not the best because you're dealing with 30+ bytes here, but they're very suitable for smaller byte strings</p>

<pre><code># proquint.rb
# adapted to ruby from https://github.com/deoxxa/proquint
module Proquint
  C = %w(b d f g h j k l m n p r s t v z)
  V = %w(a i o u)

  def self.encode (bytes)
    bytes &lt;&lt; 0 if bytes.size &amp; 1 == 1
    bytes.pack('c*').unpack('S*').reduce([]) do |acc, n|
      c1 = n         &amp; 0x0f
      v1 = (n &gt;&gt; 4)  &amp; 0x03
      c2 = (n &gt;&gt; 6)  &amp; 0x0f
      v2 = (n &gt;&gt; 10) &amp; 0x03
      c3 = (n &gt;&gt; 12) &amp; 0x0f
      acc &lt;&lt; C[c1] + V[v1] + C[c2] + V[v2] + C[c3]
    end.join('-')
  end

  def decode str
    # learner's exercise
    # or see some proquint library (eg) https://github.com/deoxxa/proquint
  end
end

Proquint.encode dat
# =&gt; dabab-rabab-habab-potat-nokab-babub-babob-bahab-pihod-bohur-tadot-dabab-dabab-habab-babab-babub-zabab
</code></pre>

<p>Of course the entire process is reversible too. You might not need it, so I'll leave it as an exercise for the learner</p>

<p>It's particularly nice for things like IP address, or any other short binary blobs. You gain familiarity too as you see common byte strings in their proquint form</p>

<pre><code>Proquint.encode [192, 168, 11, 51] # bagop-rasag
Proquint.encode [192, 168, 11, 52] # bagop-rabig
Proquint.encode [192, 168, 11, 66] # bagop-ramah
Proquint.encode [192, 168, 22, 19] # bagop-kisad
Proquint.encode [192, 168, 22, 20] # bagop-kibid
</code></pre>
Need a Ruby method to convert a binary array to ASCII alpha-numeric string
<p>I have an array of <code>[1, 0, 11, 0, 4, 0, 106, 211, 169, 1, 0, 12, 0, 8, 0, 1, 26, 25, 32, 189, 77, 216, 1, 0, 1, 0, 4, 0, 0, 0, 0, 12, 15]</code>.</p>

<p>I would love to create a string version mostly for logging purposes. My end result would be <code>"01000B0004006AD3..."</code></p>

<p>I could not find a simple way to take each array byte value and pack a string with an ASCII presentation of the byte value. </p>

<p>My solution is cumbersome. I appreciate advice on making the solution slick.</p>

<pre><code>array.each {|x| 
  value = (x&gt;&gt;4)&amp;0x0f 
  if( value&gt;9 ) then
    result_string.concat (value-0x0a + 'A'.ord).chr
  else
    result_string.concat (value + '0'.ord).chr
  end
  value = (x)&amp;0x0f 
  if( value&gt;9 ) then
    result_string.concat (value-0x0a + 'A'.ord).chr
  else
    result_string.concat (value + '0'.ord).chr
  end
}
</code></pre>