Programmieren lernen

REPORT  zfreqlist.

PARAMETERS: pa_1 TYPE string OBLIGATORY,
            pa_2 TYPE string DEFAULT ' '.

AT SELECTION-SCREEN ON VALUE-REQUEST FOR pa_1.

  DATA: lv_filename TYPE string,
        lv_path TYPE string.

  CALL METHOD cl_gui_frontend_services=>file_save_dialog
    EXPORTING
      window_title         = 'Wählen Sie die zu importierende Datei aus!'
    CHANGING
      filename             = lv_filename
      path                 = lv_path
      fullpath             = pa_1
    EXCEPTIONS
      cntl_error           = 1
      error_no_gui         = 2
      not_supported_by_gui = 3
      OTHERS               = 4.

START-OF-SELECTION.

  " Frequenztabellenstruktur
  TYPES: BEGIN OF tt_freqlist,
    string TYPE string,
    freq TYPE i,
    END OF tt_freqlist.
  " Einlesen der Eingabe


  DATA: lt_strings TYPE STANDARD TABLE OF string,
        ls_strings LIKE LINE OF lt_strings,
        lt_freq TYPE STANDARD TABLE OF tt_freqlist,
        ls_freq LIKE LINE OF lt_freq,
        lv_freq_alt LIKE LINE OF lt_freq,
        lv_helper TYPE string.

  CALL METHOD cl_gui_frontend_services=>gui_upload
    EXPORTING
      filename                = pa_1
    CHANGING
      data_tab                = lt_strings
    EXCEPTIONS
      file_open_error         = 1
      file_read_error         = 2
      no_batch                = 3
      gui_refuse_filetransfer = 4
      invalid_type            = 5
      no_authority            = 6
      unknown_error           = 7
      bad_data_format         = 8
      header_not_allowed      = 9
      separator_not_allowed   = 10
      header_too_long         = 11
      unknown_dp_error        = 12
      access_denied           = 13
      dp_out_of_memory        = 14
      disk_full               = 15
      dp_timeout              = 16
      not_supported_by_gui    = 17
      error_no_gui            = 18
      OTHERS                  = 19.
  IF sy-subrc <> 0.
    MESSAGE ID sy-msgid TYPE sy-msgty NUMBER sy-msgno
               WITH sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4.
  ENDIF.

  LOOP AT lt_strings INTO ls_strings.
    CONCATENATE lv_helper ls_strings INTO lv_helper.
  ENDLOOP.
  " Splitten der Eingabe in einzelne Felder
  SPLIT lv_helper AT pa_2 INTO TABLE lt_strings.
  " Frequenzliste wird mit den Feldern befüllt.
  LOOP AT lt_strings INTO ls_strings.
    lv_helper = ls_strings.
    ls_freq-string = lv_helper.
    APPEND ls_freq TO lt_freq.
  ENDLOOP.
  " Frequenzliste wird mit der Frequenz befüllt.
  LOOP AT lt_strings INTO ls_strings.
    LOOP AT lt_freq INTO ls_freq.
      IF ls_strings EQ ls_freq-string.
        ADD 1 TO ls_freq-freq.
        MODIFY lt_freq FROM ls_freq.
      ENDIF.
    ENDLOOP.
  ENDLOOP.

  " Einträge werden sortiert um doppelte Einträge zu löschen.
  SORT lt_freq BY string.
  " Doppelte Einträge werden gelöscht.
  LOOP AT lt_freq INTO ls_freq.
    IF ls_freq EQ lv_freq_alt.
      DELETE lt_freq INDEX sy-tabix.
    ENDIF.
    lv_freq_alt = ls_freq.
  ENDLOOP.

  " Frequenzliste wird nach Frequenz sortiert.
  SORT lt_freq BY freq DESCENDING.
  " Ausgabe.
  LOOP AT lt_freq INTO ls_freq.
    WRITE: / ls_freq-string, ls_freq-freq.
  ENDLOOP.
                

Lösung von: Alexander S. (msg systems)

/*=============================================================================\
| Könnte man natürlich noch aufhübschen (stichworte: absätze, unterscheidung
| zwischen groß- und kleinschreibung, interpunktion, doppelte leerzeichen &c.),
| aber für die aufgabe reicht's wohl.
| Diese lösung benutzt die File API und läuft daher in manchen umgebungen
| womöglich nicht ganz rund (eigentlich ist JavaScript nicht dafür gedacht,
| auf lokale Dateien zuzgreifen).
\*============================================================================*/

// eingabe (dateiauswahl)
document.write(
  '<input type="file" id="input" onchange="compute()"><br>' +
  '<div id="output"></div>'
)

function getFrequencies(txt, separator) {
  separator = separator || " ";
  var list = txt.split(separator).sort(),
      frequencyList = [],
      i;
  while (list.length > 0) {
    i = list.lastIndexOf(list[0]) + 1; // gezählt werden die vorkommen am anfang
    frequencyList.push([list[0], i]);  // array: [lexem, anzahl]
    list.splice(0, i);                 // entfernen des lexems
  }
  return frequencyList;
}

function compute() {
  var out = "";
      reader = new FileReader();
  // datei einlesen
  reader.onload = function(e) {
    var list = getFrequencies(reader.result, prompt("Trennzeichen:")),
        temp, x;
    // ausgabe als tabelle
    out = '<table>';
    for (x = 0; x < list.length; x++) {
      temp = list[x];
      out += '<tr><td>' + temp[0] + '</td><td>' + temp[1] +
        '</td></tr>';
    }
    out += '</table>';
    document.getElementById("output").innerHTML = out;
  };
  reader.readAsText(document.getElementById("input").files[0]);
}                                                          // lissalanda@gmx.at

                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#define SWAP(a, b, type) {type tmp = a; a = b; b = tmp;}

typedef struct {
	int count;
	char *str;
	struct _word *next;
}word;

word *add(word *w, char *str){
	word *new, *start;
	start = w;
	new = malloc(sizeof(word));
	new->str = malloc(strlen(str) * sizeof(char));
	new->count = 1;
	strcpy(new->str, str);
	new->next = NULL;

	if(w == NULL) return new;

	while(w->next != NULL)
			w = w->next;

	w->next = new;

	return start;
}

word *addOrIncr(word *w, char *str) {
	word *start = w;

	if (w == NULL)
		return add(w, str);

	while (w != NULL) {
		if (strcmp(w->str, str) == 0) {
			w->count++;
			return start;
		}
		w = w->next;
	}

	return add(start, str);
}

void sortList(word *list){
	if(list == NULL || list->next == NULL)
		return;

	word *it1, *it2;
	it1 = list;

	while(it1->next != NULL){
		it2 = it1->next;
		while(it2 != NULL){
			if(it1->count < it2->count){
				SWAP(it1->count, it2->count, int)
				SWAP(it1->str, it2->str, char*)
			}
			it2 = it2->next;
		}
		it1 = it1->next;
	}
}

int main(int argc, char *argv[]) {
	FILE *f;
	size_t *t = malloc(0);
	char *w;
	char *delim;
	char **ptr = malloc(sizeof(char*));
	*ptr = NULL;
	word *list = NULL;

	if(argc == 2){
		delim = malloc(strlen(" .,:;")*sizeof(char));
		strcpy(delim, " .,:;");
	}
	else
		delim = argv[2];

	if ((f = fopen(argv[1], "r")) == NULL) {
		fprintf(stderr, "\nKonnte Datei %s nicht finden/öffnen!", argv[1]);
		return EXIT_FAILURE;
	}

	while (getline(ptr, t, f) > 0) {
		if (strcmp(*ptr, "") != 0 || strcmp(*ptr, "\n") != 0) {
			w = strtok(*ptr, delim);
			while (w != NULL) {
				list = addOrIncr(list, w);
				w = strtok(NULL, delim);
			}
		}
	}

	sortList(list);

	while(list != NULL){
		printf("%s %d\n", list->str, list->count);
		list = list->next;
	}

	return EXIT_SUCCESS;
}

                

Lösung von: André Trobisch ()

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace FreqList {
  class Program {
    static void Main() {
      string file = "";
      while(!File.Exists(file)) {
        Console.Write("Datei>");
        file = Console.ReadLine();
      }

      char[] seperators = new char[] { ' ', '\n' };
      Console.Write("Tenner = Leerzeichen? (j) ");
      if(Console.ReadKey().Key != ConsoleKey.J) {
        Console.Write("\nTrenner>");
        seperators[0] = Console.ReadKey().KeyChar;
      }

      Dictionary<string, int> Counts = new Dictionary<string, int>();
      string[] content = File.ReadAllText(file).Split(seperators);
      foreach(string word in content) {
        string toLower = word.ToLower();
        if(Counts.ContainsKey(toLower)) {
          Counts[toLower]++;
        } else {
          Counts.Add(toLower, 1);
        }
      }

      foreach(KeyValuePair<string, int> Count in Counts.OrderByDescending(x => x.Value)) {
        Console.Write("\n{0} = {1}", Count.Key, Count.Value);
      }

      Console.ReadKey(true);
    }
  }
}

                

Lösung von: Marcel Kapma ()

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;

public class Main {

	public static void main(String[] args) {
		try {
			HashMap<String, Integer> map = new HashMap<String, Integer>();
			File data = new File(System.getProperty("user.home"), "test.txt");
			FileReader fr = new FileReader(data);
			BufferedReader br = new BufferedReader(fr);

			String zeile = "";

			while ((zeile = br.readLine()) != null) {
				for (String s : zeile.split(" ")) {
					if (map.containsKey(s)) {
						map.replace(s, map.get(s), map.get(s) + 1);
					} else {
						map.put(s, 1);
					}
				}
			}

			br.close();
			fr.close();

			Object[] a = map.entrySet().toArray();
			Arrays.sort(a, new Comparator<Object>() {
				public int compare(Object o1, Object o2) {
					return ((Map.Entry<String, Integer>) o2).getValue()
							.compareTo(((Map.Entry<String, Integer>) o1).getValue());
				}
			});

			for (Object e : a) {
				System.out.println(
						((Map.Entry<String, Integer>) e).getKey() + ": " + ((Map.Entry<String, Integer>) e).getValue());
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}
                

Lösung von: Name nicht veröffentlicht

import re
import operator
import os
import string
import functools

def frequenzy(path, seperator=' '):

    words_freq = {}
    
    with open(os.path.abspath(path), 'r') as file:
        splittedFile = list(map(lambda str: str.strip().replace('\n', ' ').split(seperator), file.read().split(seperator)))
        splittedFile = functools.reduce(lambda l1, l2: l1 + l2, splittedFile)
    
    for sliver in splittedFile:
        if not re.search(r'\w*[a-zA-Z]', sliver):
            continue
        if sliver in words_freq:
            words_freq[sliver] += 1
        else:
            words_freq[sliver] = 1
            
    words_freq = sorted(words_freq.items(), key=operator.itemgetter(1), reverse=True)
    
    for word, freq in words_freq:
        print('{}: {} Vorkommniss(e)'.format(word, freq))
                

Lösung von: Bester Mensch (Class)

Imports System.Collections.ObjectModel
Imports Microsoft.VisualBasic.FileIO
Imports System.Linq

Public Class Liste
    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        Dim fileDialog As New OpenFileDialog
        Dim trennzeichen As Char = " "
        fileDialog.Filter = " Text-File (*.txt) | *.txt"

        If txtTrennzeichen.Text.Length > 0 Then : Trennzeichen = txtTrennzeichen.Text : End If
        If fileDialog.ShowDialog() = DialogResult.OK Then
            ReadFile(fileDialog.FileName, trennzeichen)
        End If
    End Sub

    Public Sub ReadFile(fileName As String, delimiter As Char)
        Dim reader As New TextFieldParser(fileName)
        Dim list As New Collection(Of Frequency)
        reader.TextFieldType = FieldType.Delimited
        reader.SetDelimiters(delimiter)

        While Not reader.EndOfData()
            For Each el As String In reader.ReadFields()
                If CheckForWord(el, list) Then
                    IterateWord(el, list)
                Else
                    list.Add(New Frequency(el))
                End If
            Next
        End While

        CreateGridView(list)
    End Sub

    Public Sub CreateGridView(WordList As Collection(Of Frequency))
        dgdSummary.Rows.Clear()
        Dim query As IEnumerable(Of Frequency) = WordList.OrderByDescending(Function(Frequency) Frequency._Count)
        For Each el As Frequency In query
            dgdSummary.Rows.Add(el._Word, el._Count)
        Next
    End Sub

    Public Sub IterateWord(Word As String, WordList As Collection(Of Frequency))
        Dim sWord As Frequency = (From wrd As Frequency In WordList Where wrd._Word = Word).First()

        sWord.Iterate()
    End Sub

    Public Function CheckForWord(Word As String, WordList As Collection(Of Frequency)) As Boolean
        If (From wrd As Frequency In WordList Select wrd._Word).Contains(Word) Then : Return 1 : Else : Return 0 : End If
    End Function
End Class

Public Class Frequency
    Public _Word As String
    Public _Count As Integer = 1

    Public Sub New(Word As String)
        _Word = Word
    End Sub

    Public Sub Iterate()
        _Count += 1
    End Sub
End Class

                

Lösung von: Elias Zech (Optics Balzers)

import os, sys


def objekte_zaehlen(dictname, anzahl):
    if anzahl in dictname:
        dictname[anzahl] += 1
    else:
        dictname[anzahl] = 1
try:
    pfad = str(input("Bitte den Pfad zur Datei eingeben: "))
    if os.path.exists(pfad):
        print("Datei existiert!")
        file = open(pfad)
except IOError as Error:
    print("Es ist ein Fehler aufgetreten!")
    print(Error)
    sys.exit(0)
seperator = str(input("Bitte das Zeichen zum Trennen angeben:"))
woerter = {}

z = file.readline()
while z:
    mm = z.split(seperator) # ohne Parameterübergabe werden alle Leerzeichen und Zeilenumbrüche verwendet.
    if "\n" in mm:
        del(mm[0])
    for i in range(0, len(mm)):
        objekte_zaehlen(woerter, mm[i])
    z = file.readline()
file.close()
for item in sorted(woerter.items(), key=lambda x: x[1]):
    print(item)
                

Lösung von: Dominic Ra ()

// NET 6.x | C# 10.x | VS-2022

string path = @"C:\...\lorem.txt";
if (!File.Exists(path)) return;

var oldStr = File.ReadAllTextAsync(path).Result;
var rplStr = new System.Text.RegularExpressions.Regex(@"[.,;:!?\n]").Replace(oldStr, "");
var newStr = rplStr.Split(" ").Where(x => x.Length > 0).GroupBy(x => x).Select(x => new {word = x.Key, count = x.Count()}).OrderBy(x => -x.count).ToList();

newStr.ForEach(x => Console.WriteLine($"{x.word}: {x.count}"));
                

Lösung von: Jens Kelm (@JKooP)

// C++ 14 | VS-2022
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <vector>
#include <algorithm>
#include <map>

// Datei als String einlesen (Groß- und Kleinschreibung unterscheiden)
const std::string get_file(const std::string& path, bool c_sensitive = false) {
    std::ifstream input(path);
    if (!input) {
        std::cerr << "Pfad nicht gefunden: " << path << "\n";
        return "";
    }
    std::stringstream buffer;
    buffer << input.rdbuf();
    auto tmp{ buffer.str() };
    if (!c_sensitive)
        std::transform(tmp.begin(), tmp.end(), tmp.begin(), ::tolower);
    return tmp;
}

// String in Wörter aufsplitten (nur alphanumerische Werte erlaubt)
const auto get_split_string(const std::string& str) {
    std::vector<std::string> out{};
    std::string wrd{};
    for (const auto& c : str) {
        if (!std::isalnum(c)) {
            if (wrd.length() > 1)
                out.push_back(wrd);
            wrd.clear();
        }
        else wrd.push_back(c);
    }
    out.push_back(wrd);
    return out;
}

// Frequenzliste erstellen (Wert: Anzahl)
template<typename T>
const auto get_map(const std::vector<T>& v) {
    std::map<T, int> m;
    for (const auto& i : v)
        if (m.count(i)) m[i]++;
        else m.emplace(i, 1);
    return m;
}

// Wert und Anzahl vertauschen (für Sortierung nach Anzahl)
template<typename T, typename V>
const auto get_ordered_map(const std::map<T, V>& src) {
    std::multimap<V, T> dst;
    std::transform(src.begin(), src.end(), std::inserter(dst, dst.begin()), [](const auto& p) { return std::pair<V, T>(p.second, p.first); });
    return dst;
}

// Ausgabe (auf- bzw. absteigend)
template<typename T>
const std::ostream& print(std::ostream& os, T t, bool desc = true) {
    if (desc) // absteigend
        for (auto it{ t.rbegin() }; it != t.rend(); ++it)
            std::cout << it->second << " -> " << it->first << "\n";
    else
        for (const auto e : t)
            std::cout << e.second << " -> " << e.first << "\n";
    return os;
}

int main() {
    const auto path{ "C:\\...\\pseudo.txt" };
    auto file{ get_file(path) };
    const auto split{ get_split_string(file) };
    const auto group{ get_map(split) };
    const auto order{ get_ordered_map(group) };
    print(std::cout, order);
}
                

Lösung von: Jens Kelm (@JKooP)