[PYTHON] Ich habe versucht, eine zufällige FizzBuzz-Spalte mit Blasensortierung zu sortieren.

Einführung

Ich wollte Algorithmen wie das Blasensortieren lernen, also habe ich versucht, eine zufällige FizzBuzz-Spalte als Ausgangspunkt zu sortieren.

Erstellen Sie eine zufällige FizzBuzz-Spalte von Interesse.

Ich habe eine Funktion fzbz () definiert, die einen numerischen Wert entsprechend in FizzBuzz ändert, und make_random_fizzbuzz (), die ihn in zufälliger Reihenfolge ändert.

def fzbz(n):
  if (n%15) == 0:
    return "FizzBuzz"
  elif (n%5) == 0:
    return "Buzz"
  elif (n%3) == 0:
    return "Fizz"
  else:
    return n

import random
def make_random_fizzbuzz(start=1,finish=100):
  seq = range(start,finish+1)
  random_fizzbuzz = []
  while seq:
    random_fizzbuzz.append(fzbz(seq.pop(random.randint(0,len(seq)-1))))
  return random_fizzbuzz

Insbesondere besteht die Lösung für diesen Artikel darin, die Liste wie die folgende in einem FizzBuzz-Stil zu sortieren. (Liste erstellt mit der obigen Funktion)

Was ist Blasensortierung überhaupt (zitiert von anderen Seiten)?

Die Blasensortierung ist ein Ausrichtungsalgorithmus, der die Werte des Basiselements und anderer Elemente in einer Liste vergleicht und sie gemäß den Bedingungen austauscht.

Die Bedingung ist die Größenbeziehung des Wertes. Sortieren Sie die Liste in absteigender Reihenfolge des Werts oder in absteigender Reihenfolge des Werts.

Diese Sortierung wird als Blasensortierung bezeichnet, da bei dieser Sortierung Elemente mit höheren oder niedrigeren Werten angezeigt werden.

Algorithmusanalyse Schritte zum Anordnen der Liste in aufsteigender Reihenfolge.

Extrahieren Sie ein Element aus dem Listenbasiselement 'A'. Vergleichen Sie die Werte von Element 'A' und dem nächsten Element 'B' Tauschen Sie die Werte von Element 'A' und Element 'B' aus, wenn Element 'A' größer als Element 'B' ist. Vergleiche / tausche mit jedem Element wie Element 'A' und Element 'C', Element 'A' und Element 'D' bis zum Ende der Liste aus Das Element mit dem höchsten Wert oder das Element mit dem niedrigsten Wert in der Liste wird am Basispunkt angezeigt. Fahren Sie mit dem Basiselement (Element 'B') fort und wiederholen Sie die Schritte 2 bis 6 bis zum Ende der Liste Die Ausrichtung wird abgeschlossen, indem ein Round-Robin-Vergleich wie oben beschrieben durchgeführt und ein Austausch ausgeführt wird, der den Bedingungen entspricht. http://www.codereading.com/algo_and_ds/algo/bubble_sort.html

Ich habe eine Blasensorte in Python geschrieben, die sich vielleicht geringfügig von der oben genannten unterscheidet, aber wahrscheinlich dieselbe ist.

Erstens eine Funktion, die eine zufällige Folge von Zahlen erzeugt.

import random
def make_randoms(start=1,finish=100):
  seq = range(start,finish+1)
  randoms = []
  while seq:
    randoms.append(seq.pop(random.randint(0,len(seq)-1)))
  return randoms

Eine Funktion, die die durch die obige Funktion erzeugte Zahlenfolge sortiert und deren Bedeutung nicht gut verstanden wird.

def bubble_sort(target):
  limit = len(target)-1
  while limit > 0:
    i = 0
    while i<limit:
      if target[i]>target[i+1]:
        target[i], target[i+1] = target[i+1], target[i]
      i += 1
    limit -= 1
  return target

Zu korrigierende Punkte

Das Problem mit der zufälligen FizzBuzz-Sequenz scheint die Größenbeziehung zu sein.

    if target[i]>target[i+1]:

Mit anderen Worten, es scheint, dass wir etwas gegen diesen Bereich unternehmen sollten, in dem die Größe beurteilt wird.

Zusammenfassung der Korrektur

Daher der Code, der die Zähler f, b, fb zum Digitalisieren der Zeichenketten Fizz, Buzz, FizzBuzz und definiert

    (f,b,fb) = (3,5,15)

Eine Funktion, die Fizz, Buzz, FizzBuzz basierend auf dem Zähler quantifiziert.

def zbzf(n,f,b,fb):
  n = str(n)
  if n == 'FizzBuzz':
    return fb
  elif n == 'Buzz':
    return b
  elif n == "Fizz":
    return f
  else:
    return int(n)

Fizz, Buzz, eine Funktion, die den Zähler aktualisiert, wenn FizzBuzz angezeigt wird

def next_count(n,f,b,fb):
  if n == 'FizzBuzz':
    fb += 15
  elif n == 'Buzz':
    if (b%15) == 10:
      b += 10
    else:
      b += 5 
  elif n == "Fizz":
    if (f%15) == 12:
      f += 6
    else:
      f += 3
  return f, b, fb
  

Ich habe gemacht und versucht, jedes Element zu vergleichen und den Zähler mit diesen zu aktualisieren.

    (f,b,fb) = (3,5,15)
    while i<limit:
      if zbzf(target[i],f,b,fb)>zbzf(target[i+1],f,b,fb):
        target[i], target[i+1] = target[i+1], target[i]
      f,b,fb = next_count(target[i],f,b,fb)

Code

import random
def fzbz(n):
  if (n%15) == 0:
    return "FizzBuzz"
  elif (n%5) == 0:
    return "Buzz"
  elif (n%3) == 0:
    return "Fizz"
  else:
    return n
    
def zbzf(n,f,b,fb):
  n = str(n)
  if n == 'FizzBuzz':
    return fb
  elif n == 'Buzz':
    return b
  elif n == "Fizz":
    return f
  else:
    return int(n)

def make_random_fizzbuzz(start=1,finish=100):
  seq = range(start,finish+1)
  random_fizzbuzz = []
  while seq:
    random_fizzbuzz.append(fzbz(seq.pop(random.randint(0,len(seq)-1))))
  return random_fizzbuzz

def next_count(n,f,b,fb):
  if n == 'FizzBuzz':
    fb += 15
  elif n == 'Buzz':
    if (b%15) == 10:
      b += 10
    else:
      b += 5 
  elif n == "Fizz":
    if (f%15) == 12:
      f += 6
    else:
      f += 3
  return f, b, fb
  
def fizzbuzz_sort(target):
  limit = len(target)-1
  while limit > 0:
    i = 0
    (f,b,fb) = (3,5,15)
    while i<limit:
      if zbzf(target[i],f,b,fb)>zbzf(target[i+1],f,b,fb):
        target[i], target[i+1] = target[i+1], target[i]
      f,b,fb = next_count(target[i],f,b,fb)
      i += 1
    limit -= 1
  return target
print fizzbuzz_sort(make_random_fizzbuzz())

Ergebnis

Das zufällige FizzBuzz wurde sortiert! !!