[HaBo]

String zahl="";
eingabe="mein rechner hat 3500Mhz ..."

For Laenge der Eingabe do
  lese zeichen ein
  if istNummer_oder_Punkt(zeichen) then zahl=zahl+zeichen; (Sting zusammenbauen)
 else_block    
    if istEinSatzzeichen(zeichen)=TRUE then push(satzzeichen_stack,zeichen)
    if istEineZahl(zahl)=TRUE then push(zahlen_stack,zahl)
    zahl=""; (string wieder leer machen)
  else_block_end
od

#include <iostream>
#include <sstream>

#include "stack.h"

using namespace std;

int main()
{
    try
    {
        Stack<float> numbers(10);
        Stack<char> punctations(10);
        string input;

        cout << "Enter string: " << flush;
        getline(cin, input);

        string numBuffer;

        for (unsigned i = 0; i < input.length(); i++)
        {
            char c = input[i];

            if (c >= '0' && c <= '9' || c == '.')
            {
                numBuffer += c;
            }
            else if (c == '!' || c == '?' || c == ',' || c == ':')
            {
                punctations.push(c);
            }
            else if (numBuffer.length() > 0)
            {
                stringstream numStream(numBuffer);
                float f;
                numStream >> f;
                numbers.push(f);
                numBuffer = "";
            }
        }

        while (!numbers.isEmpty())
        {
            cout << numbers.pop() << ' ';
        }

        while (!punctations.isEmpty())
        {
            cout << punctations.pop() << ' ';
        }

        cout << endl;
    }
    catch (const char *error)
    {
        cerr << "Error: " << error << endl;
        return 1;
    }
}

#include <iostream>
#include <sstream>

#include "stack.h"

using namespace std;

int main()
{
    try
    {
        Stack<double> numbers(20);
        Stack<char>   punctations(20);
        string input;

        cout << "Enter string: " << flush;
        getline(cin, input);

        // Damit auch eine Nummer am Ende des Strings erkannt
        // wird, müssen wir ein Text-Zeichen (also !0-9 und .)
        // anhängen
        input += ' ';

        // Hier wird eine erkannte Zahl abgespeichert
        string numBuffer;

        // Die Anzahl an Punkten in der
        // momentan aufgezeichneten Zahl
        int    numOfDots = 0;

        for (unsigned i = 0; i < input.length(); i++)
        {
            char c = input[i];

            // Ziffer an Buffer anhängen
            if (c >= '0' && c <= '9')
            {
                numBuffer += c;
            }
            // Punkt anhängen und Punkt-Counter erhöhen
            else if (c == '.' && numBuffer.length() > 0)
            {
                numOfDots++;
                numBuffer += c;
            }
            // Satzzeichen speichern
            else if (c == '!' || c == '?' || c == ',' || c == ':')
            {
                punctations.push(c);
            }
            // Nummern-Buffer auslesen und in double-Wert speichern
            else if (numBuffer.length() > 0 && numOfDots <= 1)
            {
                stringstream numStream(numBuffer);
                double converted;
                numStream >> converted;
                numbers.push(converted);

                // Zurücksetzen für nächste Zahl
                numBuffer = "";
                numOfDots = 0;
            }
        }

        // Ausgabe der Nummern
        while (!numbers.isEmpty())
        {
            cout << numbers.pop() << ' ';
        }

        // Ausgabe der Satzzeichen
        while (!punctations.isEmpty())
        {
            cout << punctations.pop() << ' ';
        }

        cout << endl;
    }
    catch (const char *error)
    {
        cerr << "Error: " << error << endl;
        return 1;
    }
}

import java.util.Vector;

public class Stack{

	private Vector<Object> elemente;
	private int anzahl;

	public Stack() {
		anzahl = 0;
		elemente = new Vector<Object>();
	}
	//Ablegen von Objekten auf dem Stack
	public void push(Object obj) {
		elemente.add(obj);
		anzahl++;
	}
	//Oberstes Objekt vom Stack nehmen
	public Object pop(){
		Object o = null;
		if(!isEmpty()) {
			anzahl--;
			o = elemente.get(anzahl);
			elemente.remove(anzahl);
		}
		return o;
	}
	//Oberstes Objekt vom Stack lesen
	public Object top(){
		return elemente.get(anzahl-1);
	}
	//Prüft, ob der Stack leer ist
	public boolean isEmpty() {
		return anzahl == 0;
	}
}

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class ExtractDigits extends JFrame implements ActionListener {

	//GUI-Elemente
	private JPanel inputPanel, outputPanel;
	private JTextField input, output;
	private JLabel inputLabel, outputLabel;
	private JButton ok;
	
	//Zwei Stacks, einer für Zahlen und einer für Satzzeichen
	private Stack numbers, punctuation;
	
	//Im Konstruktor wird das JFrame zusammengebastelt und die Stacks werden initialisiert
	public ExtractDigits() { 
		super("ExtractDigits");
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		input = new JTextField(40);
		output = new JTextField(15);
		inputLabel = new JLabel("Eingabe: ");
		outputLabel = new JLabel("Ausgabe: ");
		ok = new JButton("Enter");
		
		inputPanel = new JPanel(new FlowLayout(FlowLayout.LEFT,10,5));
		inputPanel.add(inputLabel);
		inputPanel.add(input);
		inputPanel.add(ok);
		
		outputPanel = new JPanel(new FlowLayout(FlowLayout.LEFT,10,5));
		outputPanel.add(outputLabel,BorderLayout.NORTH);
		outputPanel.add(output,BorderLayout.SOUTH);
		
		ok.addActionListener(this);
		input.addActionListener(this);
		
		this.setLayout(new BorderLayout());
		this.add(inputPanel,BorderLayout.NORTH);
		this.add(outputPanel, BorderLayout.SOUTH);
		
		this.pack();
		this.setLocationRelativeTo(null);
		this.setVisible(true);
		
		numbers = new Stack();
		punctuation = new Stack();
	} //TeileString
	
	public void actionPerformed(ActionEvent e) {
		if(!input.getText().equals("")) {
			extract(input.getText());
		}
	} //actionPerformed

	// Extrahiert Zahlen und Satzzeichen aus dem Input-String und gibt sie in umgekehrter Reihenfolge aus
	private void extract(String line) {
		String number = ""; //Zwischenspeicher, um eine komplette Zahl zusammenzusetzn
		boolean floatFound = false; //Prüft, ob die Zahl schon einen Punkt hat

		for(int i=0; i<line.length(); i++) {
			
			char c = line.charAt(i); // Das aktuelle Zeichen
			
			// Ziffern oder der erste Punkt (Alle weiteren Punkte gehören nicht zur Zahl)
			if(Character.isDigit(c) || (c == '.' && !floatFound)) {
				if(number.equals("") && c == '.') number+="0"; //Wenn die Zahl mit einem Punkt beginnt setze eine Null davor
				number+=c; //Aktuelle Ziffer zum Zwischenspeicher hinzufügen
				if(c=='.') floatFound = true;
			}
			//Satzzeichen
			else if(c == '!' || c == ',' || c=='?' || c==':') {
				punctuation.push(c);
				if(number.equals("")) continue;
				numberInStack(number, floatFound);
				floatFound = false;
				number = "";	
			//Alle anderen Zeichen
			} else {
				if(number.equals("")) continue;
				numberInStack(number, floatFound);
				floatFound = false;
				number = "";	
			}
			
		}
		// Falls der Input-String mit einer Zahl aufhört, steht diese noch im Zwischenspeicher
		if(!number.equals("")){
			numberInStack(number,floatFound);
			number = "";
		}
		//Alle Zahlen vom Stack nehmen
		while(!numbers.isEmpty()) {
			number+=numbers.pop() + " ";
			
		}
		//Alle Satzzeichen vom Stack nehmen
		String punc = "";
		while(!punctuation.isEmpty()) {
			punc +=punctuation.pop() + " ";		
		}
		//Ausgabe der Zahlen und Satzzeichen
		output.setText(number+" "+punc);
	} //extract
	
	//Schreibt eine Zahl als Float oder Integer in den Stack
	public void numberInStack(String number, boolean floatFound) {
		//Wenn die Zahl mit einem Punkt aufhört wird der Punkt abgeschnitten
		if(number.endsWith(".")) {
			number = number.substring(0,number.length()-1);
			floatFound = false;
		}
		//Wenn es eine Kommazahl ist wird sie als Float auf den Stack gelegt, ansonsten als Integer
		if(floatFound) {
			numbers.push(Float.parseFloat(number));
		} else {
			numbers.push(Integer.parseInt(number));
		}	
	} //numberInStack
	
	public static void main(String[] args) {
		new ExtractDigits();
	} //main
}

using System;

namespace langeweile {
	
	public class Stack : System.Collections.Stack {
		public Stack() : base()	{}
		
		public Stack(System.Collections.ICollection elements) : base(elements) {}
		
		public Stack(Int32 size) : base(size) {}
		
		
		public bool IsEmpty() {
			return base.Count == 0;
		}
		
		public object Top() {
			return base.Peek();
		}		
	}
}

using System;
using System.Text.RegularExpressions;

namespace langeweile
{
	public class ParserResult {
		private Stack numbers;
		private Stack punctuationMarks;
		
		public Stack Numbers {
			get { return this.numbers; }
			set { this.numbers = value; }
		}
		
		public Stack PunctuationMarks {
			get { return this.punctuationMarks; }
			set { this.punctuationMarks = value; }
		}
				
		public ParserResult() {
			this.numbers = new Stack();
			this.punctuationMarks = new Stack();
		}
	}
	
	
	public class Parser	{		
		public static ParserResult Parse(string document) {			
			ParserResult result = new ParserResult();
			MatchCollection matches = Regex.Matches(document, @"(\d{1,}\.\d{1,})|(\d{1,})");
			result.Numbers = MatchCollectionToStack(matches);
			
			matches = Regex.Matches(document, @"!|,|:|\?");
			result.PunctuationMarks = MatchCollectionToStack(matches);
			return result;
		}
		
		private static Stack MatchCollectionToStack(MatchCollection matches) {
			Stack result = new Stack();
			foreach(Match match in matches) {
				result.Push(match.Value);
			}
			return result;
		}		
	}
}

using System;
using System.Drawing;
using System.Windows.Forms;

namespace langeweile
{
	public partial class MainForm : Form
	{
		[STAThread]
		public static void Main(string[] args) {
			Application.EnableVisualStyles();
			Application.SetCompatibleTextRenderingDefault(false);
			Application.Run(new MainForm());
		}
		
		public MainForm() {
			InitializeComponent();			
		}
		
		void Button1Click(object sender, EventArgs e) {
			ParserResult result = Parser.Parse(this.richTextBoxInput.Text);
			
			while(!result.Numbers.IsEmpty()) {
				this.richTextBoxOutput.AppendText(result.Numbers.Pop()+" ");
			}
			
			while(!result.PunctuationMarks.IsEmpty()) {
				this.richTextBoxOutput.AppendText(result.PunctuationMarks.Pop()+" ");
			}
		}
	}
}

    Public Function Einlesen(ByVal DerString As String, ByRef StackNum As Object, ByRef StackZei As Object) As Integer
        Dim Suchstring As String
        Dim ZeichenNummer As Integer
        Dim GefundeneZeichen As Integer
        Dim IstInZahl As Boolean
        Dim DieZahl As String
        DieZahl = ""

        Suchstring = ":,!?"

        For ZeichenNummer = 1 To Len(DerString)
            If (IstInZahl) Then
                If (IsNumeric(Mid(DerString, ZeichenNummer, 1))) Then
                    DieZahl = DieZahl & Mid(DerString, ZeichenNummer, 1)
                Else
                    StackNum.push(DieZahl)
                    IstInZahl = False
                    GefundeneZeichen = GefundeneZeichen + 1
                End If
            Else
                If (IsNumeric(Mid(DerString, ZeichenNummer, 1))) Then
                    DieZahl = Mid(DerString, ZeichenNummer, 1)
                    IstInZahl = True
                Else
                    If (InStr(Suchstring, Mid(DerString, ZeichenNummer, 1)) > 0) Then
                        StackZei.push(Mid(DerString, ZeichenNummer, 1))
                        GefundeneZeichen = GefundeneZeichen + 1
                    End If
                End If
            End If
        Next

        Return GefundeneZeichen
    End Function
End Class