gistfile1.txt

#!/usr/bin/ruby

class String 
  # Renvoie la première lettre d'une chaine
  def head
    nil
    self[0].chr unless self.empty?
  end
  
  # Renvoie la chaîne moins son premier caractère
  def tail
    nil
    self[1 - self.length, self.length] unless head == self
  end
end

def comprendre_lettre(lettre, signification)
  lettre
  signification[lettre] + " " if signification.include? lettre
end

#$recur_level = -1

def comprendre_acronyme(acr, signification, &args)
#  args ||= {}
#  comprendre_plus_fort = (not args.nil?) and args[:comprendre_plus_fort] || false
  
  return "" if acr.nil? or acr.chomp.empty?
#  $recur_level += 1
  
  lettre, reste = acr.head, acr.tail
  lettre_suivante = reste.head unless reste.nil?
  
  sens_lettre = comprendre_lettre(acr.head, signification)
  sens_reste = comprendre_acronyme(acr.tail, signification)
  sens_lettre_suivante = comprendre_lettre(lettre_suivante, signification)
  
  puts "#{" " * $recur_level}On tente de comprendre l'acronyme #{acr}, lettre #{lettre}, sens lettre #{sens_lettre}, sens lettre suivante #{sens_lettre_suivante}"
  
  case
#    when lettre.nil? then
      # La lettre courante est inconnue, on la copie
#      puts "#{" " * $recur_level}La lettre #{lettre} est inconnue"
#      sens = acr.head + sens_reste
    when (not sens_lettre.nil? and lettre_suivante.nil?) then
      # On est en train de comprendre la dernière lettre de l'acronyme
      sens = sens_lettre
    when (not sens_lettre.nil? and not sens_lettre_suivante.nil?) then
      # La lettre courante fait partie d'un acronyme (elle a un sens connu)
      # et la lettre suivante est aussi connue
      # On peut donc supposer que la lettre courante n'a pas déja été substituée
      puts "#{" " * $recur_level}La lettre #{lettre} n'a pas été substituée, on remplace par #{sens_lettre}"
      sens = sens_lettre
      sens += sens_reste unless sens_reste.nil?
    when (not sens_lettre.nil? and not lettre_suivante.nil? and sens_lettre_suivante.nil?) then
      # La lettre suivante existe et n'a pas de sens :
      # - soit l'acronyme est faux => on pourrait taper l'utilisateur
      # - soit la lettre courante a déjà été substituée, on copie
      puts "#{" " * $recur_level}La lettre #{lettre} a déjà été substituée, on copie"
      sens = lettre + sens_reste
  else
    raise "Pon"
  end
  puts "#{" " * $recur_level}L'acronyme #{acr} signifie #{sens}"
  $recur_level -=1
  sens
#  if comprendre_plus_fort
#    comprendre_acronyme(sens, signification)
#  end
end

puts comprendre_lettre("G", {"G" => "GNU's", "N" => "Not", "U" => "Unix"})

puts "'FTP' signifie #{comprendre_acronyme("FTP", {"F" => "File", "T" => "Transfer", "P" => "Protocol"})}"
puts "'GNU' signifie #{comprendre_acronyme("GNU", {"G" => "GNU's ", "N" => "Not ", "U" => "Unix "})}"
puts "'GNU' signifie #{comprendre_acronyme("GNU", {"G" => "GNU's ", "N" => "Not ", "U" => "Unix "}, :comprendre_plus_fort => true)}"