SuperStrict

Global letter_count:Int[ 26 ]
Global stream:TStream
Global line:String

stream = ReadStream( AppArgs[ 1 ] )

Repeat
	
	line = stream.ReadLine( )
	
	For Local i:Int = 0 Until line.length
		
		If( line[ i ] >= 65 And line[ i ] <= 90 )
		
			letter_count[ line[ i ] Mod 65 ]:+ 1
			
		Else If( line[ i ] >= 97 And line[ i ] <= 122 )
		
			letter_count[ line[ i ] Mod 97 ]:+ 1
			
		End If
		
	Next
	
Until( stream.Eof( ) )

stream.Close( )

For Local i:Int = 0 To 25
	
	Print( Chr( 65 + i ) + ": " + letter_count[ i ] )
	
Next

Input( "Drücke eine Taste um zu beenden" )

Strict
AppTitle="Buchstaben zaehlen"
Graphics 640,800

Global B[123],i,j,k

start()

Repeat
	Cls
	
	For i = 65 To 90
		DrawText Chr$(i)+": "+B[i],5,(i-65)*15	
	Next

	Flip
Until KeyHit(Key_Escape) Or AppTerminate()

Function start()
	Local Datei:TStream
	Datei = ReadFile("test01.txt")
	Local B2$,B3$
	'For i=0 To 1000
	Return
		B2$ = ReadLine(Datei)
		For j=0 To Len(B2)
			B3$ = Mid$(B2,j,1)
			For k = 65 To 90
				If Asc(B3$) = k Then
					B[k]:+1
				ElseIf Asc(B3$) = (k+32) Then
					B[k]:+1
				EndIf
			Next 
		Next 
	'Next 
	Until Eof(Datei)
End Function

Rem
skey-z
für BPS #1 - Buchstaben zählen
EndRem

SuperStrict

'Array deklarieren
Local ascii:Int[256]

'Datei laden
Local file:TStream=OpenFile("text.txt")

'Datei auslesen
Repeat
	
	Local line:String = ReadLine(file)
	Local lenght:Int = Len(line)
	
	'Zeile Buchstabenweise auslesen und in das Array eintragen
	For Local i:Int = 0 To lenght
	
		Rem
			Buchstaben in GROßSCHRIFT und in Ascii Code umwandeln
			ASC(buchstabe$) = buchstabe in ASCII-Code
			MID(text$, start%, länge%) = einzelne Zeichen aus dem text$ filtern
			UPPER(text) = Alle Buchstaben in Große umwandeln
		EndRem
		
		Local char:Int = Asc(Mid(Upper(line),i,1))
		
		'in Array eintragen wenn der Ascii-Code größer oder gleich null sind
		If (char >= 0) Then
			ascii[char] :+ 1
		EndIf
	Next
	
Until Eof(file) 'bis die Datei keineweiteren Zeichen enthält

CloseFile(file)

'Array auf das wesentliche verkürzen(A-Z) : siehe Slices
ascii = ascii[65..91]

'A-Z in Großbuchstaben ausgeben/verkürztes Array ausgeben
Print "----------------------------------"
Print "- Ausgabe A-Z in Grossbuchstaben -"
Print "----------------------------------"

For Local i:Int=0 To ascii.length-1
	Print Chr(i+65) + ": " +ascii[i]
Next

' BPS #1: Buchstaben zählen
'   Von Biesi
' ASCII-Code A-Z = 65-90
SuperStrict

Global buchstabenarray%[26,2]	'Array für die Zeichenzählung
Global i:Int,ii:Int			'allg. Zählvariablen
Global file:TStream			'Variable für die Dateioperationen (Vorgabe von brl.stream.TStream)
Global zeilenlaenge:Int		'Variable für die jeweilige Zeilenlänge
Global a:String				'zum Speichern des Textes

' Array für die Zeichenzählung generieren
' Erste Feld für den ASCII-Code
' Zweites Feld ist Zählfeld
For i = 0 To 25
    buchstabenarray[i,0] = i + 65
    buchstabenarray[i,1] = 0
Next

' Datei zeilenweise auslesen und verarbeiten
file=ReadFile("test.txt")
If Not file RuntimeError "Datei test.txt ist nicht vorhanden!"
While Not Eof(file)
    a$ = ReadLine(file)
    a$ = Upper(a$)				'Alle Zeichen in der Zeile zu Großbuchstaben konvertieren
    zeilenlaenge = (Len a$)-1		'Zeilenlänge ermitteln und auf Array (!! 0-...) anpassen
    For i = 0 To zeilenlaenge
        For ii = 0 To 25
	    If buchstabenarray[ii,0] = a$[i]		'Durch Arrayfeldabfrage wird der ASCII-Code übergeben
	        buchstabenarray[ii,1] = buchstabenarray[ii,1]+1	'Wenn Übereinstimmung, dann Zählfeld +1
	    EndIf
	Next
    Next
Wend
CloseStream file

' Ergebnisausgabe
For i = 0 To 25
    Print Chr(buchstabenarray[i,0])+": "+buchstabenarray[i,1]
Next

'
'
'
SuperStrict

'pfad "erfragen"
Local path:String = RequestFile( "Open", "txt" )
If Not path RuntimeError( "file not found!" )

'datei laden
Local file:TStream = ReadFile( path )
If Not file RuntimeError( "file not found!" )

'character-count array
Local characters:Int[ 256 ]

'Zeichen zaehlen
While Not Eof( file )
	Local line:String = ReadLine( file )
	
	For Local pos:Int = 0 Until line.length
		characters[ line[pos] ] :+ 1
	Next
Wend

'Ausgeben
Print "---------"

For Local i:Int = 65 To 90
	Local count:Int = characters[i] + characters[i+97-65]
	Print Chr(i) + ": " + formatedNumber(count, 5) + " |" + AsciBar( count )
Next

Print "---------"

'Datei schliessen
CloseFile( file )

'AsciBar Funktion
Function AsciBar:String( c:Int )
	Local str:String = ""
	For Local i:Int = 0 Until c
		str :+ "-"
	Next
	Return str
EndFunction

'formated number Funktion
Function formatedNumber:String( number:Int, size:Int = 4 )
	Local str:String = String( number )
	For Local i:Int = 0 Until size - str.length
		str = " " + str
	Next
	Return str
EndFunction

SuperStrict
Framework brl.Blitz
Import brl.System
Import brl.StandardIO
Import brl.Map
															'Die vier Schritte einer objektorientierten Lösung:
Local text:String=LoadText(RequestFile("Textdatei zum Auslesen auswählen","txt"))	'1. die Eingabe heranschaffen	(eine Datei laden)
Local stats:TCharStats=New TCharStats									'2. ein Objekt zum Lösen des Problems erstellen
'stats.ProcessString(text,MODE_CASE_SENSITIVE|MODE_ALL_CHARS)					'
stats.ProcessString(text)											'3. das Problem lösen lassen
Print stats.toString()												'4. das Ergebnis zurückgeben
															'Hier kommen ein paar Konstanten zur Anpassung der Statistik:
Const MODE_CASE_INSENSITIVE:Int=%1										'
Const MODE_CASE_SENSITIVE:Int=%0										'
															'
Const MODE_LETTERS_ONLY:Int=%10										'
Const MODE_ALL_CHARS:Int=%00											'
															'
Type TCharStats													'die Lösungsklasse zum BPS #1
	Field chars:TMap=New TMap										'Hier sind die einzelnen Datensätze gespeichert.
															'
	Method ProcessString(text:String,mode:Int=MODE_CASE_INSENSITIVE|MODE_LETTERS_ONLY)
		For Local i:Int=0 Until text.length							'Man gehe jedes Zeichen durch...
			ProcessChar(text[i..i+1],mode)							'...und gebe die Arbeit an jemand anderes weiter.
		Next													'
	EndMethod													'
	Method ProcessChar(char:String,mode:Int=MODE_CASE_INSENSITIVE|MODE_LETTERS_ONLY)'
		Local upperChar:String=char.toUpper()							'
		If (mode & MODE_CASE_INSENSITIVE)								'Hier kommt ein bisschen Aufblähcode durch zusätzliche Features.
			char=upperChar										'
		EndIf													'
		If (mode & MODE_LETTERS_ONLY)								'
			If upperChar<"A" Or upperChar>"Z"							'
				Return										'
			EndIf												'
		EndIf													'
		Local testChar:TChar=TChar.Create(char)							'Das besondere an dieser Klasse: Sie kann unter bestimmten Umständen
		Local charObj:TChar=TChar(chars.ValueForKey(testChar))				'(z.B. bei dem Text "sssssssssssssssssssssssssssssssssssssssssssssss")
		If charObj=Null											'speichereffizient sein.
			charObj=testChar										'(Nur dumm, dass durch den verwendeten Ansatz schnell	)
			chars.Insert(charObj,charObj)							'(ein vielfaches an Speicher benötigt wird...			)
		EndIf													'
		charObj.IncrementCounter()									'Dieser Methode ist das Zählen zu umständlich.
															'Diese Arbeit wird daher weitergegeben.
	EndMethod													'
	Method toString:String()										'Für eine schön formatierte Ausgabe sorgt diese Methode.
		Local text:String											'
		For Local charObj:TChar=EachIn(chars.Values())					'Jedes Zeichen wird beachtet!
			text:+charObj.toString()+"~r~n"							'Es muss aber auch etwas dafür machen. (->Arbeit wurde weitergegeben.)
		Next													'
		Return text												'
	EndMethod													'
EndType														'
															'
Type TChar														'
	Field char:String												'Damit das Zeichen weiß, was es ist, merkt es sich das.
	Field count:Long=0											'Hier wird es auch mit großen Texten keine Probleme geben.
															'ganz vorbildlich:
	Function Create:TChar(char:String)									'Es gibt hier sowohl eine Create-Funktion...
		Return New TChar.Init(char)									'
	EndFunction													'
	Method Init:TChar(char:String)									'...als auch eine Init-Methode zum Erstellen des Objektes.
		Self.char=char											'
		Return Self												'
	EndMethod													'
	Method IncrementCounter()										'Pfui! Was hat hier Mathematik in diesem Code zu suchen?
		Self.count:+1											'
	EndMethod													'
	Method Compare:Int(other:Object)									'Damit kann man die Objekte auch als Schlüssel in den Bäumen nutzen.
		Return -other.Compare(Self.char)								'
	EndMethod													'
	Method toString:String()										'Hier wird die artgerechte Ausgabe des Zeichens ermöglicht.
		If char=" "												'
			Return "~q ~q: "+count									'
		ElseIf char>" "											'
			Return char+": "+count									'
		Else													'
			Return "["+char[0]+"]: "+count							'
		EndIf													'
	EndMethod													'
EndType														'

t$=Lower(LoadText(RequestFile("")))
For i="a"[0] To "z"[0]
	Print Chr(i)+": "+(Len(t)-Len(t.Replace(Chr(i),"")))
Next