Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Schraubensack (Felder)

Herr Schlosser Schraubensack hat einen Posten alter Schrauben (s) und Muttern (m) erstanden. Sein Lehrling hat ihm in Kleinarbeit jede Schraube und jede Mutter ausgemessen und in einem Sack verpackt. Leider sind nun alle Schrauben und Muttern zusammen im selben Sack gelandet, sodass es schwierig ist, herauszufinden, ob eine passende Mutter zu einer gleich großen Schraube vorhanden ist.

Zum Glück hat der Lehrling eine Liste angefertigt in folgendem Stil

m 3
s 4
m 8
m 4
...

Dabei steht der Buchstabe m für Mutter und s für Schraube. Die dahinterliegende Zahl gibt den Durchmesser in Millimetern an.

Nun will Herr Schraubensack wissen, wie viele passende Paare er zu jeder Größe hat. Er will nun die Liste anders vor sich haben:

4mm: 8 passende Paare
5mm: 7 passende Paare
6mm: ...
...

Schreiben Sie ein Programm, das die Schrauben und Muttern als Tabelle entgegen nimmt (siehe zip-Download); mit anderen Worten: Der Input Ihres Programmes ist die ursprüngliche Arbeit des Lerhlings. Die Ausgabe soll im verlangten Format (mm / Anzahl passende Paare) ausgegeben werden. Für die nicht passenden Einzelteile muss keine Ausgabe gemacht werden. Hat es z. B. für 4mm acht Schrauben und 5 Muttern, so sind lediglich 5 Paare auszuweisen.

Dateien:

1 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

Kommentare (1)

c0der 17. Juni 2016 09:46   reply report
Für die ABAP Lösung habe ich die Schrauben.txt modifiziert und alle New Lines durch ; ersetzt.

7 Lösung(en)

package ch.programmieraufgaben.arrays.schraubensack;

import java.io  .*;
import java.util.*;

/**
 * Herr Schlosser Schraubensack (Programmieraufgaben.ch Code: uk54-0btd)
 * @version 0.1 (Mar 20, 2016)
 * @author Philipp Gressly Freimann 
 *         (philipp.gressly@santis.ch)
 */
public class Schraubensack {

	public static void main(String[] args) {
			new Schraubensack().top();
	}


	int[] paare = new int[100]; // keine Schrauben > 100mm vorhanden ;-)


	void top()  {
		String[] objekte = einlesen("src/ch/programmieraufgaben/arrays/schraubensack/schrauben.txt");
		for(int pos = 0; pos < objekte.length; pos ++) {
			if("".equals(objekte[pos].trim())) {
				continue;
			}

			char typ         = objekte[pos].charAt(0);
			char gegenstueck = 'm' == typ ? 's' : 'm';
			int  size        = Integer.parseInt(objekte[pos].substring(1).trim());
			if(hatGegenstueck(objekte, pos, gegenstueck, size)) {
				entferneStueck(objekte, typ        , size);
				entferneStueck(objekte, gegenstueck, size);
				paare[size] = paare[size] + 1; // Inkrement
			}
		}
		ausgabe();
	}


	void ausgabe() {
		for(int i = 0; i < paare.length; i++) {
			if(paare[i] > 0) {
				if(1 == paare[i]) {
					System.out.println(i + "mm: " + paare[i] + " passendes Paar");
				} else {
					System.out.println(i + "mm: " + paare[i] + " passende Paare");
				}
			}
		}
	}


	void entferneStueck(String[] objekte, char typ, int size) {
		boolean stueckentfernt = false;
		String  typStr         = typ  + " " + size;
		int pos = 0;
		while(! stueckentfernt) {
			if(typStr.equals(objekte[pos])) {
				objekte[pos] = "";
				stueckentfernt = true;
			}
			pos = pos + 1;
		}
	}


	boolean hatGegenstueck(String[] objekte, int pos, char gegenstueck, int size) {
		String suchstring = gegenstueck + " " + size;
		for(int p = pos + 1; p < objekte.length; p++) {
			if(suchstring.equals(objekte[p])) {
				return true;
			}
		}
		return false;
	}


	String[] einlesen(String filename)  {
		ArrayList<String> as = new ArrayList<String>(5000);
		
		try (FileReader       fr  = new FileReader(filename); 
				 LineNumberReader lnr = new LineNumberReader(fr))
		{
			String line;
			line = lnr.readLine();
			while(null != line) {
				as.add(line);
				line = lnr.readLine();
			}
		} catch (Exception e) {
			System.out.println("Fehler " + e);
			return null;
		}
		//Collections.sort(as); // mit sortierten Daten wäre ein effektiferer Algorithmus möglich.
		return as.toArray(new String[0]);
	}

}  // end of class Schraubensack
                

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

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

namespace Schraubensack {
  class Program {
    static void Main() {
      string file;
      Console.Write("Datei>");
      file = Console.ReadLine();
      
      Dictionary<int, Dictionary<char, int>> Sack = new Dictionary<int, Dictionary<char, int>>();
      if(File.Exists(file)) {
        string[] Ausdruck;
        foreach(string Zeile in File.ReadAllLines(file)) {
          Ausdruck = Zeile.Split(' ');
          char posten = Ausdruck[0].ToCharArray()[0];
          int größe = Convert.ToInt32(Ausdruck[1]);

          if(!Sack.ContainsKey(größe))
            Sack.Add(größe, new Dictionary<char, int>() {
              { 's', 0 }, { 'm', 0 }
            });

          Sack[größe][posten]++;
        }

        foreach(KeyValuePair<int, Dictionary<char, int>> Paar in Sack.OrderBy(x => x.Key)) {
          int min = Paar.Value.Values.Min();
          if(min > 0) {
            Console.WriteLine("{0}mm: {1} passende Paare", Paar.Key, min);
          }
        }

        Console.ReadKey(true);
      }
    }
  }
}

                

Lösung von: Marcel Kapma ()

public class Gewinde {
	private int AnzahlSchrauben;
	private int AnzahlMuttern;

	public Gewinde neueSchraube() {
		AnzahlSchrauben = 1;
		return this;
	}

	public Gewinde neueMutter() {
		AnzahlMuttern = 1;
		return this;
	}

	public int getAnzahlSchrauben() {
		return AnzahlSchrauben;
	}

	public void addSchraube() {
		AnzahlSchrauben++;
	}

	public int getAnzahlMuttern() {
		return AnzahlMuttern;
	}

	public void addMutter() {
		AnzahlMuttern++;
	}
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.HashMap;

public class Schrauben_sortieren {
	static HashMap<Integer, Gewinde> Liste = new HashMap<Integer, Gewinde>();

	private static void einlesen(String datei) throws IOException {
		BufferedReader reader = new BufferedReader(new FileReader(datei));
		String zeile = reader.readLine();

		while (zeile != null) {
			String[] tokenArray = zeile.split("(\\s)");

			String Typ = tokenArray[0];
			int groesse = Integer.parseInt(tokenArray[1]);

			if (Liste.containsKey(groesse)) {
				if (Typ.compareTo("s") == 0)
					Liste.get(groesse).addSchraube();
				else
					Liste.get(groesse).addMutter();
			} else {
				if (Typ.compareTo("s") == 0)
					Liste.put(groesse, new Gewinde().neueSchraube());
				else
					Liste.put(groesse, new Gewinde().neueMutter());
			}
			zeile = reader.readLine();
		}
		reader.close();

	}

	private static void ausgabe() {
		for (int GewindeAusgabe : Liste.keySet()) {
			int Muttern = Liste.get(GewindeAusgabe).getAnzahlMuttern();
			int Schrauben = Liste.get(GewindeAusgabe).getAnzahlSchrauben();

			if (Schrauben != 0 && Muttern != 0)
				if (Schrauben <= Muttern)
					System.out.println(GewindeAusgabe + "mm " + Schrauben + " passende Paare");
				else
					System.out.println(GewindeAusgabe + "mm " + Schrauben + " passende Paare");
		}
	}

	public static void main(String[] args) throws IOException {
		einlesen("src/schrauben.txt");
		ausgabe();
	}

}


                

Lösung von: Name nicht veröffentlicht

# -*- coding: utf-8 -*-
import sys

muttern = {}						# Dictionary für Mutterngrößen
schrauben = {}						# Dictionary für Schraubengrößen

# Funktion Zählen einer Mutter / Schraube
def objekt_zaehlen(dictname,groesse):
	if groesse in dictname:                   # gibt es die Größe schon?
		dictname[groesse] += 1             # ja, jetzt ein Mal mehr
	else:
    	dictname[groesse] = 1                 # nein, Größe erstmalig zählen

# Datei öffnen, komplett einlesen und schließen
try:
	datei = open("./schrauben.txt")
except:
	print("Datei nicht gefunden")
	sys.exit(8)
allezeilen = datei.readlines()
datei.close()

# eingelesene Datei zeilenweise verarbeiten
for zeile in allezeilen:
	eingabe = zeile.split()
	if eingabe[0] == "m":
		objekt_zaehlen(muttern,int(eingabe[1]))         # als integer speichern für spätere korrekte Sortierung
    else:
	    objekt_zaehlen(schrauben,int(eingabe[1]))

# sortierte Ausgabe der Schrauben-/Mutternpaare
s1 = sorted(muttern)                        # welches die steuernde Liste ist, ist egal. Hier -> muttern
for groesse in s1:
	if groesse in schrauben:
		if muttern[groesse] <= schrauben[groesse]:
			print groesse, "mm: ", muttern[groesse], " passende Paare"
		else:
			print groesse, "mm: ", schrauben[groesse], " passende Paare"

                

Lösung von: J. Reppe ()

var items = getListFromFile(),
    pairs = new Array(100).fill(0),
    item, mate;

// datei als array einlesen
function getListFromFile() {
  var file = new XMLHttpRequest();
  file.onreadystatechange = function() {
    if (file.readyState == 4 && file.status == 200)
      sessionStorage.tmp = file.responseText;
  };
  file.open("GET", "schrauben.txt", false);
  file.send();
  return sessionStorage.tmp.split("\n");
}

// suchfunktion
while (items.length > 1) {
  item = items.shift();                             // stück einlesen
  mate = item.charAt(0) == "m" ? "w" : "m";         // gegenstück bestimmen
  mate += item.substr(1);
  if (items.indexOf(mate) > -1) {                   // fund:
    pairs[parseInt(item.split(" ")[1])]++;          // paarzahl erhöhen
    items.splice(items.indexOf(mate), 1);           // stück entfernen
  }
}

// ausgabe
pairs.forEach(function(val, i, arr){
  if (val > 0) document.write(i + " mm: " + val + " Stück<br>");
});                                                         // lissalanda@gmx.at

                

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

REPORT  zschraubensack.

TYPES: BEGIN OF tt_schrauben,
  art TYPE c,
  mm TYPE i,
  END OF tt_schrauben,
  BEGIN OF tt_paare,
    mm TYPE i,
    anzahl_s TYPE i,
    anzahl_m TYPE i,
    anzahl_p TYPE i,
    END OF tt_paare.

DATA: lt_liste TYPE STANDARD TABLE OF string,
      ls_liste LIKE LINE OF lt_liste,
      lt_schrauben TYPE STANDARD TABLE OF tt_schrauben,
      ls_schrauben LIKE LINE OF lt_schrauben,
      lt_mutter TYPE STANDARD TABLE OF tt_schrauben,
      ls_mutter LIKE LINE OF lt_mutter,
      lv_helper1 TYPE c,
      lv_helper2 TYPE string,
      lv_string TYPE string,
      lt_paare TYPE STANDARD TABLE OF tt_paare,
      ls_paare LIKE LINE OF lt_paare,
      lv_paare_alt LIKE LINE OF lt_paare.

CALL METHOD cl_gui_frontend_services=>gui_upload
  EXPORTING
    filename                = 'D:\Users\schulza\Desktop\schrauben.txt'
  CHANGING
    data_tab                = lt_liste
  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_liste INTO ls_liste.
  CONCATENATE lv_string ls_liste INTO lv_string.
ENDLOOP.

CLEAR lt_liste.

" Splitten der Eingabe in einzelne Felder
SPLIT lv_string AT ';' INTO TABLE lt_liste.

LOOP AT lt_liste INTO ls_liste.
  SPLIT ls_liste AT ' ' INTO lv_helper1 lv_helper2.

  CASE lv_helper1.
    WHEN 's'.
      ls_schrauben-art = lv_helper1.
      ls_schrauben-mm = lv_helper2.
      ls_paare-mm = lv_helper2.
      APPEND ls_paare TO lt_paare.
      APPEND ls_schrauben TO lt_schrauben.
    WHEN 'm'.
      ls_mutter-art = lv_helper1.
      ls_mutter-mm = lv_helper2.
      ls_paare-mm = lv_helper2.
      APPEND ls_paare TO lt_paare.
      APPEND ls_mutter TO lt_mutter.
  ENDCASE.
ENDLOOP.

" Einträge werden sortiert um doppelte Einträge zu löschen.
SORT lt_paare BY mm.
" Doppelte Einträge werden gelöscht.
LOOP AT lt_paare INTO ls_paare.
  IF ls_paare EQ lv_paare_alt.
    DELETE lt_paare INDEX sy-tabix.
  ENDIF.
  lv_paare_alt = ls_paare.
ENDLOOP.

LOOP AT lt_schrauben INTO ls_schrauben.
  LOOP AT lt_paare INTO ls_paare WHERE mm EQ ls_schrauben-mm.
    ADD 1 TO ls_paare-anzahl_s.
    MODIFY lt_paare FROM ls_paare.
  ENDLOOP.
ENDLOOP.

LOOP AT lt_mutter INTO ls_mutter.
  LOOP AT lt_paare INTO ls_paare WHERE mm EQ ls_mutter-mm.
    ADD 1 TO ls_paare-anzahl_m.
    MODIFY lt_paare FROM ls_paare.
  ENDLOOP.
ENDLOOP.

LOOP AT lt_paare INTO ls_paare.
  IF ls_paare-anzahl_s NE 0 AND ls_paare-anzahl_s < ls_paare-anzahl_m.
    ls_paare-anzahl_p = ls_paare-anzahl_s.
    MODIFY lt_paare FROM ls_paare.
  ELSEIF ls_paare-anzahl_m NE 0 AND ls_paare-anzahl_m < ls_paare-anzahl_s.
    ls_paare-anzahl_p = ls_paare-anzahl_m.
    MODIFY lt_paare FROM ls_paare.
  ELSEIF ls_paare-anzahl_s EQ ls_paare-anzahl_m AND ls_paare-anzahl_s NE 0.
    ls_paare-anzahl_p = ls_paare-anzahl_s.
    MODIFY lt_paare FROM ls_paare.
  ENDIF.
ENDLOOP.

LOOP AT lt_paare INTO ls_paare WHERE anzahl_p ne 0.
  WRITE: / ls_paare-mm NO-GAP, 'mm:' NO-GAP, ls_paare-anzahl_p NO-GAP, 'passende Paare'.
ENDLOOP.
                

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

#!/usr/bin/ruby
# Autor: Ivo Blöchliger
# n: Anzahl Zeilen, a: Anzahl Schraubengrössen

data = Hash.new
File.open("schrauben.txt","r"){|f|
   while(line=f.gets) # Zeile einlesen
     was = line[0] == "m" ? 0 : 1
     d = line[2..-1].to_i
     unless data.has_key?(d)  # Hash-Zugriffe sollten O(log(a)) sein
        data[d] = [0,0]
     end
     data[d][was]+=1
   end
}
# Der folgende Sort ist O(a log(a)), was weniger
# als O(n log(a)) der obigen Schlaufe ist.
data.keys.sort.each{|d|
   n = data[d].min
   if n>0
     puts "#{d}mm: #{n} passende#{n==1 ? "s" : ""} Paar#{n>1 ? "e" : ""}"
   end
}

                

Lösung von: Ivo Blöchliger (Kantonsschule am Burggraben, St. Gallen)

Verifikation/Checksumme:

4mm: 39 passende Paare
5mm: 35 passende Paare
6mm: 36 passende Paare
7mm: 42 passende Paare
8mm: 48 passende Paare
9mm: 41 passende Paare
10mm: 38 passende Paare
11mm: 41 passende Paare
12mm: 49 passende Paare
13mm: 45 passende Paare
14mm: 54 passende Paare
15mm: 48 passende Paare
16mm: 46 passende Paare
17mm: 44 passende Paare
18mm: 32 passende Paare
19mm: 41 passende Paare
20mm: 46 passende Paare
21mm: 37 passende Paare
22mm: 43 passende Paare
23mm: 35 passende Paare
24mm: 36 passende Paare
25mm: 27 passende Paare
26mm: 27 passende Paare
27mm: 16 passende Paare
28mm: 23 passende Paare
29mm: 26 passende Paare
30mm: 18 passende Paare
31mm: 12 passende Paare
32mm: 18 passende Paare
33mm: 11 passende Paare
34mm: 11 passende Paare
35mm: 8 passende Paare
36mm: 8 passende Paare
37mm: 7 passende Paare
38mm: 8 passende Paare
39mm: 3 passende Paare
40mm: 2 passende Paare
41mm: 3 passende Paare
42mm: 3 passende Paare
47mm: 1 passendes Paar
48mm: 1 passendes Paar
50mm: 1 passendes Paar

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 1
Schwierigkeit: Mittel
Webcode: uk54-0btd
Autor: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen