roebe 0.5.187

data/doc/core/array.md

@@ -0,0 +1,1142 @@
+## Create an Array with 5 random numbers:
+
+    Array.new(5) { rand(10) }
+
+## Obtain a random element from an Array (rand tag):
+
+    [1,2,3].sample
+
+## Output the second element of an Array, called array:
+
+    puts array[1]
+
+## Obtain the last 3 elements of an Array:
+
+    array.last(3)
+
+# Obtain the first 3 elements of an Array:
+
+    array.first(3)
+
+## Checking for a substring in an Array:
+
+    array = %w( cat dog help )
+    array.each {|entry| puts entry if entry.include?('do') }
+
+  # or use .select
+
+    array.select { |t| t if t.include?('do') } # => ['dog']
+
+## Obtaining the min as well as max value of an Array (#minmax)
+
+    array = [1,5,33,11]; array.minmax # => [1, 33]
+
+## Querying whether an Array has only (and exactly only) one element:
+
+    array.one?
+
+## Creating a 2-dimensional Array:
+
+    array = Array.new(2) { Array.new(5) { 0 } }
+    pp array # => [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
+
+## Creating a 3-dimensional Array:
+
+    array = Array.new(3) { Array.new(4) { Array.new(7) } }
+    pp array
+      
+## Taking the first element of an Array and putting it at the end of the Array:
+
+  Use <b>.rotate()</b>.
+
+  Usage example:
+
+    [ 'a', 'b', 'c', 'd' ].rotate # => ['b', 'c', 'd', 'a']
+
+## How to concatenate/merge the first two elements of an Array together
+  
+    x = %w( cat dog horse )
+    x[0] += x[1]
+    x.delete_at(1); x # => ['catdog', 'horse']
+
+## How to create an Array from a to z?
+
+    ('a'..'z').to_a # This makes use of a Range.
+
+## How can we put the wanted parts of an Array into a new array and reject the other entries?
+   "Die Guten ins Töpfchen, die Schlechten ins Kröpfchen"
+
+    rejected, good = [1, 2, 3, 4].partition { |a| a == 1 } # => [[1], [2, 3, 4]]
+
+## How can we remove only specific elements from an array, such as those of a certain length?
+
+  Use <b>.reject</b> as in:
+
+    (1..30).reject {|i| i % 4 == 0 } # => [1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14, 15, 17, 18, 19, 21, 22, 23, 25, 26, 27, 29, 30]
+
+    %w( cat dog monkey ).reject {|s| s.size > 4 } # => ["cat", "dog"]
+
+## Are there any advantages that an Array has, compared to a Hash?
+
+  An Array is more efficient - and thus faster - than a Hash.
+
+## How do we show elements of an Array?
+
+  If the name of the array is <b>foo</b>, then it is possible to
+  refer to the first element in that Array via either of these
+  two methods:
+
+    foo[0]
+    foo.first
+
+  The second element can be referred via:
+
+    foo[1]
+
+  The third element can be accessed via:
+
+    foo[2]
+
+  And so on and so forth.
+
+  The formula here is: n-1. Element number 10 can thus
+  be accessed via foo[9].
+
+## How to we re-arrange an Array?
+
+  Use the <b>.shuffle!</b> method such as:
+
+    x = [1,2,3]
+    x.shuffle!
+
+## How can we remove the first three elements of an Array?
+
+    a = [1, 2, 3, 4, 5, 0]
+    a.drop(3) # => [4, 5, 0]
+
+  .drop() will always remove a Range. If we wish to remove
+  a specific element then <b>.delete_at()</b> should be
+  used.
+
+  This is possible since as of Ruby 1.8.7.
+
+## How can we invert an Array?
+
+  Use:
+
+    ["foo","bar","fii"].reverse
+      
+## How to append new data to an Array?
+
+  Via <b>.push</b> it is possible to append new data
+  onto the <b>end of an Array</b>:
+
+    array.push("d", "e", "f") # => leads to  ["a", "b", "c", "d", "e", "f"]
+
+  Note that << is better, though, as it is also faster, and fewer 
+  characters to type:
+
+    array << ("d", "e", "f")
+
+## How do we create an Array with the String 'cat' 8 times?
+
+    Array.new(8, 'cat') # => ["cat", "cat", "cat", "cat", "cat", "cat", "cat", "cat"]
+
+## How can we determine the position of an array member? (array subsequence, array index, array position)
+
+  Use <b>.index</b>.
+
+  Take note that <b>.index</b> is an alias towards <b>.find_index</b>.
+
+  Usage example:
+
+    index = data.find_index { |entry| entry[0].downcase.include?(i) }
+
+## How do we obtain a specific element stored in an Array?
+
+  Make use of <b>.at</b>.
+
+  Example:
+
+    array = ['a', 'b', 'c', 'd', 'e']
+    array.at(0)  # => 'a'
+    array.at(-1) # => 'e'
+
+  You can also use <b>.clear</b>, as in array.clear. This will remove all
+  elements from our array in question and thus empty it again.
+
+  Example for this follows next:
+
+    a = ['a','b','c']
+    a.clear
+    a # => []
+
+## How can we output the content of an Array together with the index?
+
+    array = ["5",5,222]  
+    array.each_with_index { |item, index| puts "  "+index.to_s + " => " + item.to_s }
+
+## How can we create an Array from 0 to 100?
+
+  Make use of .to_a as well as a Range object, via:
+
+    array = (0 .. 100).to_a # => [0, 1, 2, 3, 4, 5, 6, 7, ... and so forth
+
+## How to remove all nil-values from an Array?
+
+  Make use of the method <b>.compact</b> such as in:
+
+    array.compact!
+
+## How do we dump an Array of Strings?
+
+    array = ["foo","bar"]
+    array.map {|s| s.dump}.join(",") # => ""foo","bar""
+
+    # or
+
+      %w( foo bar fee faa ).map {|s| s.dump}.join(" <----> ") # => 
+      "foo" <----> "bar" <----> "fee" <----> "faa"
+
+## Links to Arrays
+
+  https://ruby-doc.org/3.2.0/Array.html
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## Wie füge ich neue Einträge an ein Array hinzu? (array push)','array
+    Ähnlich wie in der Programmiersprache Perl, kann man in Ruby
+      folgende Methoden verwenden:
+
+    join, push, pop,insert or to say, array.join, array.push, 
+      array.pop, array.insert, array.shift
+
+    .pop <b>entfernt</b> das letzte Element eines Array (und
+      gibt es wieder).
+
+    Beispiel:
+
+      a = ["a","b"] # => ["a", "b"]
+      a.pop # => "b" # Das "Gegenteil" von pop ist übrigens
+      <b>.shift</b> # .shift
+      a     # => ["a"]
+
+    <span class="col">.push</span> fügt das Element am 
+      <b class="yel">Ende des Arrays hinzu</b>
+      (muss man aber nicht verwenden, es existiert ja auch noch
+      &#60;&#60; ist sogar schneller als .push)
+
+    Jedoch kann man mittels .push mehrere Elemente auf einmal
+      hinzufügen, &#60;&#60; hingegen erlaubt es einem nur jeweils
+      ein Element hinzuzufügen.
+
+    <span class="col">.pop</span> <b class="yel">entfernt das letzte Objekt</b>
+
+    <span class="col">.last</span> <b class="yel">sagt was an letzter
+      Stelle im Array vorkommt</b>, aber verändert nichts. .last() akzeptiert
+      auch Argumente.
+
+    Mittels <span class="col">.length</span> sieht man wie lange ein 
+      Array ist. (Das alias zu .length ist .size. Ich verwende in meinem
+      Code ausschliesslich <span class="col">.size</span>)
+
+    <span class="col">.insert</span>(position,value) lets you add anything
+      to the array at any position you want to by putting the value at
+      position, and moving everything else behind that position by
+      +1. (insert(0,nil)). Allerdings bevorzuge ich [] statt 
+      insert.
+
+    Mittels <span class="col">.shift</span> entfernt man 
+      <b class="yel">das erste Element eines Array und gibt es wieder</b>. 
+      (The other elements are shifted down by one).
+
+    Mittels <span class="col">.unshift</span> wird das Objekt zu 
+      <b class="s1 yel">Beginn des Array hinzugefügt</b> (quasi
+      ein <i class="bold">left-add</i>):
+
+      a = [ "b", "c", "d" ]
+      a.unshift("z") # => ["z", "b", "c", "d"]
+      a.unshift 1, 2 # => [ 1, 2, "a", "b", "c", "d"]
+      array = [ "a", "b", "c" ]
+      cmd("  %w( b c d ).unshift 'a' # => ['a', 'b', 'c', 'd']")+
+
+    
+
+    <b>.join()</b> ist immer dann wichtig wenn man Elemente eines
+      Arrays miteinander verknüpfen möchte.
+
+    Beispiel:
+
+      array = [ "a", "b", "c" ]
+      array.join(" - ") # leads to "a - b - c"
+      array * " - " # leads to "a - b - c", is an alias to .join
+
+    * auf Array angewandt ist ein Alias zu .join
+
+      a('http://www.ruby-doc.org/core-2.1.0/Array.html#method-i-join
+
+    Die genannten Commands sind keine Funktionen sondern 
+      Methodenaufrufe, wobei wir hier self. weglassen 
+      können.
+
+    Sie sehen Funktionen natürlich ähnlich.
+
+
+
+
+## Wie lösche ich ein Array Member an einer bestimmten
+      Position? (remove member at position)
+
+    Am besten geht dies mittels <b>.delete_at</b>.
+
+      array = ["a","b","c","d"]
+      array.delete_at(0) # => ["b", "c", "d"]
+      array = ["ant", "bat", "cat", "dog"]
+      array.delete_at(2) # => "cat"
+      array # => ["ant", "bat", "dog"]
+
+## Was ist mit pack und unpack? (Array.pack, Array.unpack)','pack
+    Das ganze ist ein wenig komplizierter ...
+
+    Zuerst einmal sollte man folgende <b class="lightblue">Tabelle</b>
+      studieren, um diese Art Code entschlüsseln zu können:
+
+      table3('marr1em marl1em martb1em s1_5em BG_White Black','','',
+        '<b>Format</b>','<b>Function</b>','<b>Returns</b>',
+        'A','String with trailing nulls and spaces removed.','String',
+        'a','String.','String',
+        'B','Extract bits from each character (msb first).','String',
+        'b','Extract bits from each character (lsb first).','String',
+        'C','Extract a character as an unsigned integer.','Fixnum',
+        'c','Extract a character as an integer.','Fixnum',
+        'd','Treat sizeof(double) characters as a native double.','Float',
+        'E','Treat sizeof(double) characters as a double in little-endian byte order.','Float',
+        'e','Treat sizeof(float) characters as a float in little-endian byte order.','Float',
+        'f','Treat sizeof(float) characters as a native float.','Float',
+        'G','Treat sizeof(double) characters as a double in network byte order.','Float',
+        'g','Treat sizeof(float) characters as a float in network byte order.','Float',
+        'H','Extract hex nibbles from each character (most significant first).','String',
+        'h','Extract hex nibbles from each character (least significant first). ','String',
+        'I','Treat sizeof(int) 1 successive characters as an unsigned native integer.','Integer',
+        'i','Treat sizeof(int) 1 successive characters as a signed native integer.','Integer',
+        'L','Treat four1 successive characters as an unsigned native long integer.','Integer',
+        'l','Treat four1 successive characters as a signed native long integer.','Integer',
+        'M','Extract a quoted-printable string.','String',
+        'm','Extract a base64 encoded string.','String',
+        'N','Treat four characters as an unsigned long in network byte order.','Fixnum',
+        'n','Treat two characters as an unsigned short in network byte order.','Fixnum',
+        'P','Treat sizeof(char *) characters as a pointer, and 
+         return len characters from the referenced location.','String',
+        'p','Treat sizeof(char *) characters as a pointer to a 
+         null-terminated string.','String',
+        'S','Treat two1 successive characters as an unsigned short in 
+         native byte order.','Fixnum',
+        's','Treat two1 successive characters as a signed short in native byte order.','Fixnum',
+        'U','Extract UTF-8 characters as unsigned integers.','Integer',
+        'u','Extract a UU-encoded string.','String',
+        'V','Treat four characters as an unsigned long in little-endian 
+         byte order.','Fixnum',
+        'v','Treat two characters as an unsigned short in little-endian 
+         byte order.','Fixnum',
+        'X','Skip backward one character.','---',
+        'x','Skip forward one character.','---',
+        'Z','String with trailing nulls removed.','  String',
+        '@','Skip to the offset given by the length argument.','   ---'
+      )+
+
+## Wie konvertiere ich einen Array in einen Hash? Die neuen Hash Keys
+      sollen wie die Array Members sein, so das ein Array wie ["a","b"] ein Hash
+      in dieser Form {"a"=>"a","b"=>"b"} sein sollte (array to hash, array2hash,
+      to_hash, array_to_hash)
+
+      array.inject(Hash.new) { |h, i| h[i] = i }
+
+    oder
+
+      array = %w( a b c d); hash = Hash[*array.zip(array).flatten]
+      Hash[ *[1,2,3,4] ] # => {1=>2, 3=>4}
+      Hash[[["code", "01"], ["value", "02"]]] # => {"code"=>"01", "value"=>"02"}
+
+    Oder noch besser:
+
+      Hash[*"foo,bar,xyz,123".split(",")] # => {"xyz"=>"123", "foo"=>"bar"}
+
+    Ein weiteres Beispiel:
+
+      a.inject({}) { |m,o| m.merge o }
+
+## Wie merge ich einen hash?(merge hash, hash merge, merge 
+      tag)','merge_hash # merge tag
+      h1 = { "a" => 100, "b" => 200 }
+      h2 = { "b" => 254, "c" => 300, "d" => 400 }
+      h1.merge(h2) # => {"a" => 100, "b" => 254, "c" => 300, "d" => 400}','merge
+      h1           # => {"a" => 100, "b" => 200}
+
+    Man braucht <b>.merge!</> um diese Änderungen "permanent" zu machen.
+
+    Obacht - wenn ein Key in beiden Hashes vorhanden 
+      ist, dann wird der erste Key <b>überschrieben</b>!
+
+    Hash.update ist Hash.merge recht ähnlich:', id: 'hash_update # rf ruby hash_update
+
+      h1 = { "a" => 100, "b" => 200 }
+      h2 = { "b" => 254, "c" => 300, "d" => 400 }
+      h1.update(h2) # => {"a"=>100, "b"=>254, "c"=>300, "d"=>400}
+
+    Man erkennt, das der Wert von b mittels update überschrieben wurde 
+      - update ist also genau wie merge, ausser das <b>update die Werte 
+      überschreibt</b> während merge dies nicht tut.
+
+    Und um das ganze dauerhaft zu implementieren, verwendet
+      man <b>.merge!</b>
+
+      # ========================================================================= #
+      # === Joining an Array.
+      # ========================================================================= #
+## Gibt es eine <b>Array.join_by_array</b> Methode?
+    Ja, indirekt - über <b>.zip</b>','','zip
+
+      ["a","b","c","d"].join_by_array(["1","2"])
+      ["a","b","c","d"].zip ["1","2"]) # => 
+      [["a", "1"], ["b", "2"], ["c", nil], ["d", nil]]"
+
+    Mittels <b>.zip</b> kann man zwei Arrays kombinieren (das
+      Reissverschlussverfahren):
+
+      a = [1,2,3]
+      cmd("  b = ['a','b','c']")+
+      a.zip(b) # => [[1, "a"], [2, "b"], [3, "c"]]
+
+      # ========================================================================= #
+      # Wie mache ich einen Array "kleiner":
+      # ========================================================================= #
+## Wie kann ich einen Array, der andere Arrays enthält,
+      auf einen Array bringen?
+
+      array.flatten! oder array.flatten
+
+    .flatten akzeptiert ein Argument, <b>level</b> genannt.
+      Am besten sieht man sich folgendes Beispiel an um zu verstehen
+      wie .flatten mit Argument funktioniert.
+
+      a = [[1, 2, 3], 3, [[2224, 4412421]]]
+      a.flatten 1 # => [1, 2, 3, 3, [2224, 4412421]]
+
+    Man sieht, der ursprüngliche Array wurde nur einmal geflattened.
+
+## Was macht .any?
+
+      cmd("  Returns true if the block is true for any of the array's elements")+
+      cmd("  $ary.any? {|_| _.include? 'a'} # => true")+
+
+    Damit kann man auch partial includes durchführen:
+
+      cmd("  ['[]', '[DONE]', 'DONE'].any? { |x| x =~ /DO/ } # => true")+
+      cmd("  array = %w( abc def ghi$ ).any? {|entry| entry.include? '$' } # => true")+
+
+## Wie lösche ich jedes 2. Element in einem Array?
+      array = [ 2,251152,512152,51252,2552,52,5252 ]
+      flag = true
+      puts array.delete_if { flag = (not flag) }
+
+## Wie initialisiere ich einen Array using weird syntax?      
+      x = [ [] ] * 5 # => [[], [], [], [], []]
+
+    Eine andere Art einen Array aufzufüllen ist diese hier:
+
+      list_of_var_names.each {|v| instance_variable_set("@#{v}", "") }
+
+## Was macht Array.map?
+
+    Es ist ein Synonym für collect. Beide tun folgendes:
+
+      s2('Invokes block once for each element of arr, replacing the 
+      element with the value returned by block. (It only does a 
+      real replacing if ! is used)','lightblue s2em BLOCK BO
+
+    Mit anderen Worten wird etwas auf jedes Element eines Array 
+      angewendet, und dann der neue Array zurückgegeben.
+
+    Die .map Methode ist im module Enumerable definiert. 
+      Hash und Range enthalten ebenso die Enumerable method.
+
+    A good yet easy way to use it is to calculate something, like
+      multiplying each element of an array with 5, and getting the 
+      result)','lightblue BO
+
+      a = [ "a", "b", "c", "d" ]
+      a.map! {|x| x + "!" } # leads to ,["a!", "b!", "c!", "d!"]
+      a,  # ["a!", "b!", "c!", "d!"]
+    [1,2,3].map {|e| e * 3 }   # => new array: [3,6,9]
+    [3,12,53].map {|e| e * 5 } # => new array:  [15, 60, 265]
+
+## Wie teile ich einen Array auf und gebe die Mitglieder an 
+      eine Methode?
+
+      method(*[a, b, c])
+
+    Dies ist das gleiche wie:
+
+      method(a, b, c)
+
+
+## Wie mache ich ein Array, including using a Range object and 
+      additionally how do I verify the class of a var?
+
+    Use [], as in
+
+      array = [1, 2, "3"]
+
+    oder
+
+      array = [% w(1 2 "3") ]
+
+    The [] is a shortcut for this
+ 
+    <i class="BO gold">Array.[](position1,position2)</i>
+      and so on
+
+    To find out about the class use varname.class, as in
+
+      puts array.class
+
+    If you need to use the index, you can use
+ 
+    .each_with_index (each_with_key...)','yel
+
+## How can I get multidimensional arrays?
+    Hier gibt es mehrere Wege. 
+
+    Der erste Weg geht über die <b>Matrix</b> Klasse:
+
+      cmd("  require 'matrix'")+
+      Matrix.I(3)
+      Matrix[[0,1],[2,0]] * Vector[1.2,3.4]
+
+## Wie addiere ich [1,2] mit [2,3] zu [3,5]?
+
+       Matrix[[1],[2]] + Matrix[[2],[3]] # => Matrix[[3], [5]
+
+    Another way is to use the ArrayMD extension of the Array class. 
+      Look at my custom_functions.rb file. Here is an example that stores 
+      a 8 / 8 chess map.
+
+    array_storing_all_fields = ArrayMD.new
+    i = 1
+    y = 1
+    64.times do ' )+
+      cmd2('  array_storing_all_fields[y][i] = "da is was"+rand(2892892).to_s 
+      cmd2('  if i % 8 == 0
+      cmd3('    i = 0
+      cmd3('    y += 1
+      cmd2('  end
+      cmd2('  i += 1 
+    end
+
+## Wie teste ich, ob ein Array i einem anderen Array inkludiert
+      ist?
+
+    Verwende dies
+
+      cmd("  array1 = ['fred','peter','janning']")+
+      cmd("  array2 = ['joe','peter','frank','jimbo']")+
+      array1.each do |item|
+      cmd2('  if array2.include? item
+      cmd3('    puts "   Listing found in the Array that has these 
+      members -- #{array1} == Found this item: #{item} =="
+      cmd2('  end
+      cmd2('  puts
+      cmd2('  puts
+    end
+
+## Ich will je 3 Member eines Array ausgeben, 
+      wie geht dies?','array_members # rf ruby array_members
+    Verwende das hier:
+
+      num.step(limit, step) { |i| block }','step
+      0.step($ary.size, 3) do |x| p $ary[x, 3] end' )+
+      0.step(3) { |x| p $ary[x, 3] }
+      (100 .. 500).step(55) {|x| print x,", "} # => 100, 
+      155, 210, 265, 320, 375, 430, 485, # => 100..500
+      array = [1, 2, 3, 4, 5, 6]; array.slice(2)
+ 
+## How do I get the even numbers from an 
+      array? (even numbers, odd numbers)
+      array = [1,4,6,22,31,51]
+      array.map {|i| i % 2 == 0 }
+
+    oder
+
+      array.select { |i| i % 2 == 0 }','select # rf ruby select
+      (1..10).select { |i| i % 2 == 0 } # => [2, 4, 6, 8, 10]
+
+    Oder noch kürzer:
+
+      (1..10).select { |i| i.even? }
+      (1..10).select { |i| i.odd? }
+
+    Mit <b>.select</b> wählt man Elemente aus dem Block aus, 
+      für <b>die die Bedingung true ist</b>.
+
+     Das folgende Beispiel gibt alle Nummern zurück die 
+      durch 3 teilbar sind, und zwar von 1 bis 5000
+
+      (1..5000).select {|i| i % 3 == 0 } # Wählt 3,6,9,12
+      etc.. aus
+
+## How can I check whether something is included in 
+      an array or not? (inarray, is in array, in_array)
+      a = [ "a", "b", "c" ] #
+      a.include?("b") # true
+
+    If you want to do this for an object called x and the array y
+
+      y.member?(x)
+
+      frage("I am used to perl's qw(). How to make this in ruby? Is
+      there a shortcut for creating arrays? (quoted words)")+
+      x = %w(63 362 63632 dog cat)
+
+    The lowercased %w extracts space-separated 
+      tokens into array elements.
+
+     The uppercased %W does double-quoted string subtiutions. 
+      Useful if you want to use variables.
+
+    Beispiel für %W:
+
+    x=%W(  one two -#{Time.now}-)
+
+## Wie suche ich nach einem String in einem Array?','grep
+      array = ["one","two","three","four"]
+      array.grep("three")
+
+## How do i output array member 12 to 24?
+      array[12,24]
+
+      frage("I got an array filled with strings. I want to output the 
+      strings that are larger than LIMIT chars. How?")+
+    LIMIT = 5
+    array = [ "hin", "hoe","yodelyo","makutatete" ]
+    puts array.find_all { |e| e.size > LIMIT }
+
+    To complete it , there is another way using case but this 
+      one is not so nice...
+    array.each do |e|; case e.size; when 4; #....; end; end
+
+      frage("If I have an array of integers, how can i find out 
+      which one is the highest one before a limes number? And 
+      which one is the highest one in a group of integers")+
+    Hmm. Mach daraus eine Klasse:
+
+    class Array 
+      def count(&action) 
+      cmd2('    count = 0 
+      cmd2('    self.each { |v| count = count + 1 if action.call(v) }
+      cmd2('    return count 
+      end 
+      end
+
+      a = Array[1, 2, 3, 2,22,4,24, 5, 6, 7, 8, 9, 10]
+      puts a.count { |v| v < 5 }
+
+    This is the same as this by the way (Enumerable#find_all):
+
+      a = (1..10).to_a
+      puts a.find_all {|v| v < 5 }.size
+      x = $iarray.inject do |y,z|
+      cmd2('    y > z ? y : z
+      end
+
+    Or use <b>array.max</b>
+
+    <b>.select</b> ist ein alias zu .find_all, und wohl
+      auch gebräuchlicher.
+
+    You can also use the dot notation to re-index an 
+      existing array, for example:
+
+    a = [1,3,5,7,9]
+    a[1..4] # leads to [1,3,5,7]
+
+    If you would have used a[1...4] instead,
+      then the last number would not have been included.
+
+      e("I have an array consisting of numbers. How can I 
+      make the sum and product of those numbers?")+
+
+    Use inject, as in
+
+    [1,3,5,7,9,22].inject(0) {|sum, element| sum+element}
+
+    # and for the product
+
+    [1,3,5,7,9,22].inject(1) {|product, element| product*element}
+
+    Inject must be set to 1 for the first time because it is the
+      multiplier. If it is 0, no output will be generated - 0 * anything
+      is still 0.
+
+    Actually, you dont need any params in the above examples.
+
+## How do I output each member of an array? How do I output the 
+      content of an array? How can i ignore certain chars like . and ..,
+      ie how can i exclude . and ..? (each array member)
+
+    Use sth like 
+
+      a.each {|x| print x, " - " }
+
+    About the second question, use
+      cmd("  unless ( x == '.') || (x == '..')")+
+    Output it:
+
+      puts array
+
+## I have an array with 1000 entries. How can i slice the
+      first 100 entries and move them to the end of the array?
+    Verwende in etwa folgenden Code:
+
+      array = (1..1000).to_a
+      array += array.slice!(0, 99)
+      puts array
+
+## I want to use the name of an array. How can i do this?
+    class Array
+
+      cmd2('  attr_accessor :name
+
+    end
+
+    def xs(inp)
+      cmd2("puts inp.name + ':' + inp.join(' ')")+
+    end
+
+      cmd("(xpa12 = ['foo', 'bar']).name = 'xpa12'")+
+      cmd("(xpa13 = ['bla', 'ble']).name = 'xpa13'")+
+      d = xpa13
+      xs(xpa12)  # => xpa12:foo bar
+      xs(d)      # => xpa13:bla ble
+
+## Can i duplicate the content of an array?
+      array *2
+
+      frage("I have input between 1-100 entries (integers). I want to 
+      initialize a class for each entry. How to do?")+
+    Initialize an array.
+
+    players = []
+
+    And if you know how many entries , you could use
+      this(of course adapt for your class, and your needs):
+
+    (1..players_n).each { |n| players[n] = PlayerData.new(5,5,5) }
+
+    The block-form of Array.new also yields the index
+
+      players = Array.new(player_count) { Player.new }
+
+    Beispiel:
+
+    Array.new(3) { |x| x * 2 } would give you [0, 2, 4]
+
+    Remember, with Array.new() you can declare how many
+      entries the array shall contain.
+
+    How do I add new entries to an array? 
+
+    Use + or just define a new member of the array. 
+      Examples are following.
+
+    Given the above solution, use <span class="col">array + ["foo", "bar"]</span>.
+      In general, if you define a new entry number, it will be added to the array, 
+      for example via <span class="col">array[5] = "five"</span>.
+
+## Wie frage ich ein Objekt ob es ein Array ist?
+      object.is_a? Array
+
+## Wie mache ich dynamische Arrays?
+    At first glance these seems to be a little bit tricky.
+
+    First basics are, that you can assign multidimensional arrays, as
+      in
+
+      x =[   [1, 2, 3], [4, 5, 6], [7, 8]   ]
+
+    You can access this array as in
+
+      y=x[1]
+
+    and redefine parts of it
+
+      six = x[1][2]
+
+## How do I get the first entry of an array?
+    Sometimes you will have an array
+      containing other arrays, and you want to get the first
+      entry of each of these entries.
+
+    Then this method call can turn out to be useful:
+
+      array = [ "q","r","s","gjklgjkl" ]
+      array.first
+      array.first(3)
+
+## How do I delete entries from an array?
+    Use -. 
+      If you know the name of the entry, you can delete 
+      it via
+
+    array - [ "name" ]
+
+    You can also use <b>Array#delete</b> 
+
+## How do I join members of an array using a token of my 
+      choice?
+      cmd("  foo.join(', ')")+
+
+    You can do this is a more complex manner, like 
+      append something after you joined them, see
+
+      cmd("  foo.join(' (and) ') + '8)'")+
+
+    How do I sort arrays?
+    Lets take the array x = [ 1, 7, 3 ]. 
+
+    We can now sort it by doing 
+      <span class="col">x.sort</span>. This handsomely works 
+      with strings as easily.
+
+    You can also reverse arrays, like
+    <span class="col">
+      x.reverse</span>.
+
+    Please note that ruby has the <=> operator, which 
+      simplifies sorting. Just try it in your irb like 3 <=> 1.
+
+    And because you want it, here is another Example:
+
+    primzahlen = [ 11, 5, 7, 2, 13, 3 ]
+    primzahlen.sort
+
+    Und noch Namen:
+
+    namen = [ "Melissa", "Daniel", "Samantha", "Jeffrey","Idiot","RubyRules"]
+    namen.sort
+
+    I need to create 1001 words for an array. Is there a simple way 
+      to do it? An alternate array way to initialize strings?
+
+    Let some script make the words for you or gather the necessarray 
+      data. Manually you can do this
+
+    <span class="col">%w</span> which tells ruby that the following 
+      data is meant to be used as words in an array. Example:
+
+      foo = %w{ one two three four five }
+
+    You can still access them via
+
+      foo[0]
+
+    and so on.
+
+## How do I convert an array into a string?
+    Use <span class="col">join</span>.
+      Given the array variable above, you can use it like this: 
+      <span class="col">str= array.join(".")</span>
+
+    How do I convert a string into an array? (string split=
+
+    Use <span class="col">split</span>, like in 
+      <span class="col">str.split(":")</span>
+
+    Actually, this does a bit more, because it splits your string 
+      at the given keyword, and returns an array with the remaining 
+      information.
+
+    You could use it to retrieve some info as in:
+
+    x = "xxx  100% 7932KB   2.6MB/s   00:03" yyy  100%   10MB   2.6MB/s   00:04"
+
+      frage("Wie applizierte ich etwas something on each member of
+      an array? (each array, each member array)")+
+    Use <span class="col">each</span>, like in
+
+    foo.each { |current_item|
+      cmd2('  puts current_item
+    }
+
+    Dont forget, every member of an array is also an object in 
+      ruby, and the each is actually called an iterator.
+
+    An example is the following:
+
+      ["dog","cat","bird"].each {|i|
+      cmd2('    printf "This is a %s\n", i
+    }
+
+    And for cool effects, combine it with a loop:
+
+      (1..10).each {|i|
+      cmd2('    print sprintf("%04d\n", i)
+      }
+
+    We can combine this with sort and downcasing as well
+
+    y.each do |x|
+      print x.downcase
+    end;puts
+
+## How do I split a string at a given token, and create an array 
+      with the remaining information? (split string, string2array)
+    array = "foo bar doo car".split(" ")
+    puts array
+
+    The character given in split() is called <b>delimiter</b>.
+    If you dont need an array:
+
+      "string foo bar".split
+
+    or
+
+    "string foo bar".split("o")
+
+      # === Delete duplicated array members
+      frage("Wie kann ich duplizierte Mitglieder eines Array löschen und
+      wie kann ich all jene Mitglieder löschen, die bestimmte 
+      Kriterien erfüllen? (Ein Filter. remove duplicates / array duplicate / 
+      array delete member / array delete entry)")+
+      a = ["a","a","b","c"]
+      puts a.uniq # => a,b,c # Alle weiteren a-Einträge nach 
+      dem ersten a werden gelöscht
+
+      # === Delete members of an Array
+    Mitglieder eines Array kann man so löschen: 
+
+      a = ["a","a","b","c"]
+      a.delete("a")
+      puts a # b c
+
+      # === Find all duplicates of an Array
+## Wie finde ich alle Duplicates eines Array?
+      def only_duplicates(array)
+      cmd2('   duplicates = []
+      cmd2('   array.each {|member| duplicates << member if array.count(member) > 1}
+      cmd2('    duplicates.uniq
+      end
+
+    << ist ein Alias zu push, nicht zu concat.
+
+    Ein anderer Weg ist folgender (ist besser da er keinen weiteren
+      Array benötigt):
+
+      array.detect { |e| array.count(e) > 1 }
+
+    Genauer:
+
+      array = [1, 2, 1, 3, 5, 4, 5, 5] # => [1, 2, 1, 3, 5, 4, 5, 5]
+      dup = array.select{|element| array.count(element) > 1 } # => [1, 1, 5, 5, 5]
+      dup.uniq # => [1, 5]
+      dup # => [1, 1, 5, 5, 5]
+
+## Ich habe einen Array mit Zahlen. Wie erhalte ich die
+      Summe davon?
+      [1,3,4].reduce(:+) # => 8
+
+## Wie kann ich 32 zufällige Arrays erstellen die von 
+      0 bis 26 variieren können?
+      Array.new(32) { rand(26) }
+
+## Wie erhalte ich ein bestimmtes Produkt eines Array?
+    %w(a b c).product([*1..3]).map(&:join) # => ["a1", "a2",
+      "a3", "b1", "b2", "b3", "c1", "c2", "c3"]
+
+## Wie kann ich einen Array in zwei Arrays aufteilen?
+      [1, 2, 3, 4].each_slice(2).to_a # => [[1, 2], [3, 4]]
+
+## Wie erreiche ich eine Intersektion (Gemeinsamkeiten)
+      zwischen 2 Arrays?
+      %w( abc def ghi ) & %w( ghi jkl mno ) # => ["ghi"]
+
+## Wie finde ich heraus ob ein Array einen anderen
+      Array inkludiert?
+      cmd("  require 'set'")+
+
+      array.to_set == other_array.to_set
+      $ary1.to_set == $ary2.to_set
+      %w( b c a ).to_set.subset?(%w( a b c ).to_set) # => true
+
+## Wie finde ich heraus ob ein Array empty (leer) ist?
+      array.empty?
+
+## Wie finde ich einen Index in einem Array?
+      array = ["1", "2", "3", "4", "5", "6", "7",
+      "8", "9", "0", "a", "b", "c", "d", "e", "abc",
+      "cat", "dog", "a", nil, nil]
+
+      cmd("  array.find_index 'cat' # => 16")+
+
+      # Find subarray in an array.
+## Wie finde ich einen bestimmten Subarray in einem Array?
+      %w( abc def ghi ).index {|x| x =~ /de/ } # => 1
+
+## Wie teile ich einen Array auf in n Subarrays? (split
+      array in two)
+      [1,2,3,4,5,6].each_slice(2) {|slice| p slice} # =>  
+      [1, 2], [3, 4], [5, 6]
+
+## Wie kann ich jedes Mitglied eines Array in einen
+      neuen Array werfen?
+      %w( Red Green Blue Yellow ).product # =>
+      [["Red"], ["Green"], ["Blue"], ["Yellow"]]
+
+## Wie lösche ich Elemente die repetitiv nacheinander folgen?
+       [1, 1, 2, 3, 2, 2, 1].chunk {|i| i }.map(&:first)
+
+## Wie gebe ich einen Array wieder, aber in umgekehrter Reihenfolge?
+      [1,2,3,4,5].reverse_each {|x| puts x}
+
+## Wie und wieso verwende ich .to_ary, und wie hängt
+      dies mit .try_convert zusammen?
+    Jede Klasse in Ruby kann eine <b>to_ary</b> Methode definieren.
+
+    Dies erlaubt es dieser Klasse in einen Array konvertiert zu werden.
+
+    Beispiel:
+
+      cmd( '  class Foo
+      cmd2('    def to_ary
+      cmd3('      ["John", "Doe", "Yo"]
+      cmd2('    end
+      end
+
+      cmd( '  Array.try_convert Foo.new
+    Mit anderen Worten, hier versucht man einen Array zu erstellen.
+
+## Wie finde ich gemeinsame Elemente zwischen 2 oder mehr Arrays?
+    Mittels dem Intersection-Operator <b>&</b>.
+
+      ["a","b","c"] &  ["b","f","g"] # => ["b"]
+
+## Wie vereine ich 2 Arrays? (Array merge, merge array)
+    Dies geschieht mittels .concat, wobei + recht ähnlich zu 
+      .concat ist, jedoch eine copy erstellt:
+
+      array1 = %w( a b c )
+      array2 = %w( e f g )
+      array1.concat(array2) # => ["a", "b", "c", "d"]
+      array1 + array2
+
+    Wieso verwenden wir hier nicht << statt contact? Da .concat auch
+      <b>automatisch ein .flatten anwendet</b>, << hingegen nicht.
+
+## Wie erstelle ich ein Union von 2 Arrays ohne Duplikate?
+    Mittels dem <b>| Operator</b>.
+
+      %w( a b c d e f ) | %w( c d a ) # => ["a", "b", "c", "d", "e", "f"]
+
+## Wie kann ich den Array auswählen der ein bestimmtes 
+      Element aufweisen kann?
+    Dies geht mittels <b>.assoc</b>
+
+      array1 = %w( colours red blue green white )
+      array2 = %w( letters a b c d e )
+      s3 = "foo"
+      a = [array1, array2, s3]
+      a.assoc "letters" # => ["letters", "a", "b", "c",
+      "d", "e"]
+
+
+
+## Wie kann ich alle Kombinationen eines Array darstellen?
+    Mittels .combination().
+
+## Wie erhalte ich die Anzahl an Elementen in einem Array?
+      %w( 1 2 3 4 5 6 6 6 ).count("6") # => 3
+
+## Wie fülle ich einen Array mit bestimmten Elementen?
+      cmd("  %w( a b c ).fill('z',3,4) # => ['a', 'b', 'c',
+      'z','z', 'z', 'z']")+
+
+## Wie erhalte ich den Index eines Elements zur rechten
+      Seite?
+    Mittels .rindex()
+
+      %w( a b c d e f g b h i ).rindex("b") # => 7
+
+## Was macht <b>.transpose</b>?','transpose # rf ruby transpose
+    Die <b>.transpose</b> Methode auf Arrays - transpose heisst
+      "vertauschen" - nimmt einen existierenden, 2-dimensionalen
+      Array (eine Matrix) und verändert sie an einer Seite:
+
+    a = [[1,2], [3,4], [5,6]]
+    puts a.transpose.inspect # => [[1, 3, 5], [2, 4, 6]]
+
+    Noch ein Beispiel:
+
+      [[1,2,3,4],[:a, :b, :c, :d]].transpose 
+      # => [[1, :a], [2, :b], [3, :c], [4, :d]]
+
+    Mit anderen Worten, das erste Element jedes Array wird zu
+      einem neuen Array. Das funktioniert aber nicht mit Arrays
+      denen ein Element fehlt, daher diese Lösung:
+
+    class Array
+      cmd2('  def safe_transpose
+      cmd3('    result = []
+      cmd3('    max_size = self.max { |a,b| a.size <=> b.size }.size
+      cmd3('    max_size.times { |i|
+      cmd4('      result[i] = Array.new(self.first.size)
+      cmd4('      self.each_with_index { |r,j| result[i][j] = r[i] }
+      cmd3('    }
+
+      cmd3('    result
+      cmd2('  end
+    end
+
+    Nun kann <b>safe_transpose</b> angewandt werden.
+
+    Es berechnet die Länge of the longest row and uses that as
+      the baseline to perform the transposition.
+
+    So our original example becomes:
+
+      a = [[1,2], [3,4], [5]]
+      puts a.safe_transpose.inspect
+      [[1, 3, 5], [2, 4, nil]]
+
+## Wie erhalte ich die Summe eines Integer-Array?','integer_sum
+      array = [ 5,2,52,52,2,54,5444 ]
+      array.inject(0) { |x,y| x+y } # => 5611
+
+    Oder in einer Wurscht:
+
+      [ 5,2,52,52,2,54,5444 ].inject(0) { |x,y| x+y } # => 5611
+
+    Inject wurde zuerst in Smalltalk verwendet und funktioniert wie folgt:
+
+    The first time the block is called, x will be set to the 
+      value given in inject, in our case 0, while y will be the value 
+      of the first array member.
+
+    Danach wird x an den Rückgabewert des Blocks gleichgesetzt.
+