fun main() {
val verwaltung = Musikverwaltung()
val song1 = Song("Led Zeppelin", "Led Zeppelin", 180, 90)
val song2 = Song("Led Zeppelin II", "Led Zeppelin", 147, 80)
val song3 = Song("Led Zeppelin III", "Led Zeppelin", 260, 72)
val song4 = Song("[Led Zeppelin IV]", "Led Zeppelin", 451, 85)
val song5 = Song("Houses of the Holy", "Led Zeppelin", 332, 94)
val song6 = Song("Physical Graffiti", "Led Zeppelin", 174, 100)
val song7 = Song("Presence", "Led Zeppelin", 80, 67)
val song8 = Song("In Through the Out Door", "Led Zeppelin", 270, 93)
verwaltung.hinzufuegen(song1)
verwaltung.hinzufuegen(song2)
verwaltung.hinzufuegen(song3)
verwaltung.hinzufuegen(song4)
verwaltung.hinzufuegen(song5)
verwaltung.hinzufuegen(song6)
verwaltung.hinzufuegen(song7)
verwaltung.hinzufuegen(song8)
val newPlaylist = Playlist(mutableListOf<Song>(song1, song2, song3))
val zufallsPlaylist: Playlist = verwaltung.zufallsPlaylist()
val dynPlaylist = DynamicPlaylist(mutableListOf<Song>(song1, song2, song3))
val bew = 80
newPlaylist.alleAbspielen()
println("\nSpieldauer von newPlaylist: ${newPlaylist.gesamteSpieldauer()} Sekunden, ${String.format("%.2f",newPlaylist.gesamteSpieldauer() / 60.0)} Minuten")
println("\nAnzahl der Songs mit einer Bewertung von $bew oder besser: ${newPlaylist.SpieldauerMitXOderBesser(bew)}")
println("\n-----SEPERATOR-----\n")
zufallsPlaylist.alleAbspielen()
println("\nSpieldauer von zufallPlaylist: ${zufallsPlaylist.gesamteSpieldauer()} Sekunden, ${String.format("%.2f",zufallsPlaylist.gesamteSpieldauer() / 60.0)} Minuten")
println("\nAnzahl der Songs mit einer Bewertung von $bew oder besser: ${zufallsPlaylist.SpieldauerMitXOderBesser(bew)}")
println("\n-----SEPERATOR-----\n")
dynPlaylist.alleAbspielen()
println("\nSpieldauer von dynPlaylist: ${dynPlaylist.gesamteSpieldauer()} Sekunden, ${String.format("%.2f",dynPlaylist.gesamteSpieldauer() / 60.0)} Minuten")
println("\nAnzahl der Songs mit einer Bewertung von $bew oder besser: ${dynPlaylist.SpieldauerMitXOderBesser(bew)}")
//dynPlaylist Test
dynPlaylist.add(song6)
println("\n-----SEPERATOR-----\n")
dynPlaylist.alleAbspielen()
println("\nSpieldauer von dynPlaylist: ${dynPlaylist.gesamteSpieldauer()} Sekunden, ${String.format("%.2f",dynPlaylist.gesamteSpieldauer() / 60.0)} Minuten")
println("\nAnzahl der Songs mit einer Bewertung von $bew oder besser: ${dynPlaylist.SpieldauerMitXOderBesser(bew)}")
println("\n-----SEPERATOR-----\n")
val testSong = dynPlaylist.take()
println(testSong?.titel)
dynPlaylist.alleAbspielen()
println("\nSpieldauer von dynPlaylist: ${dynPlaylist.gesamteSpieldauer()} Sekunden, ${String.format("%.2f",dynPlaylist.gesamteSpieldauer() / 60.0)} Minuten")
println("\nAnzahl der Songs mit einer Bewertung von $bew oder besser: ${dynPlaylist.SpieldauerMitXOderBesser(bew)}")
println("\n-----SEPERATOR-----\n")
dynPlaylist.reset()
dynPlaylist.alleAbspielen()
println("\nSpieldauer von dynPlaylist: ${dynPlaylist.gesamteSpieldauer()} Sekunden, ${String.format("%.2f",dynPlaylist.gesamteSpieldauer() / 60.0)} Minuten")
println("\nAnzahl der Songs mit einer Bewertung von $bew oder besser: ${dynPlaylist.SpieldauerMitXOderBesser(bew)}")
val besterSong: Song = verwaltung.besterSong()
println("\nDer beste Song in der Datenbank ist: ${besterSong.titel} von ${besterSong.interpret}, Spieldauer: ${besterSong.spieldauer / 60.0}, Bewertung: ${besterSong.bewertung}")
do{
println("Bitte geben Sie einen Suchbegriff ein!")
val eingabe = readLine().toString()
if(eingabe != "stopp") {
val seekSong = verwaltung.suchen(eingabe)
seekSong?.abspielen() ?: println("\nIhre Suche ergab keine Treffer!\n")
}
}
while(eingabe != "stopp")
val player = Wiedergabe(newPlaylist, 0)
/*
player.startStopErneut(0)
player.nMalNeachsterSong(3)
player.startStopErneut(1)
println("aktuellerSong: ${player.aktuellerSong}")
player.startStopErneut(1)
player.neachsterSong()
println("aktuellerSong: ${player.aktuellerSong}")
player.wiedergabemodusSetzen(2)
println("aktuellerSong: ${player.aktuellerSong}")
player.neachsterSong()
println("aktuellerSong: ${player.aktuellerSong}")
*/
}
import kotlin.random.Random
class Wiedergabe(var aktuellePlaylist: Playlist, var wiedergabemodus: Int){
var aktuellerSong: Int = 0
fun aktuellePlaylistSetzen(zuSetzendePlaylist: Playlist){
aktuellePlaylist = zuSetzendePlaylist
}
fun wiedergabemodusSetzen(zuSetzenderWiedergabemodus: Int){
wiedergabemodus = zuSetzenderWiedergabemodus
}
fun neachsterSong(){
var wiederholen: String = "n"
if( wiedergabemodus == 0) {
do {
if(aktuellerSong < aktuellePlaylist.songliste.size) {
aktuellePlaylist.songliste.get(aktuellerSong).abspielen()
aktuellerSong++
}
if(aktuellerSong < aktuellePlaylist.songliste.size) {
println("Wiederholen? y/n")
wiederholen = readLine().toString()
}
else {
wiederholen = "n"
startStopErneut(1)
}
}while (wiederholen != "n")
}
else if(wiedergabemodus == 1){
do {
for (s in aktuellePlaylist.songliste)
s.abspielen()
println("Wiederholen? y/n")
wiederholen = readLine().toString()
}while (wiederholen != "n")
}
else{
do{
aktuellePlaylist.songliste.get(Random.nextInt(aktuellePlaylist.songliste.size)).abspielen()
println("Wiederholen? y/n")
wiederholen = readLine().toString()
}while (wiederholen != "n")
}
}
fun nMalNeachsterSong(n: Int){
for (s in 0..n)
neachsterSong()
}
fun startStopErneut(action: Int){
if(action == 0){
neachsterSong()
}
else if(action == 1)
aktuellerSong = 0
else {
aktuellerSong = 0
neachsterSong()
}
}
}
open class Playlist(val songliste: MutableList<Song>) {
open fun gesamteSpieldauer() = songliste.sumBy { it.spieldauer }
fun SpieldauerMitXOderBesser(x: Int): Int {
var tmp: Int = 0
for (s in songliste) {
if(s.bewertung >= x){
tmp += 1
}
}
return tmp
}
open fun alleAbspielen() {
for (s in songliste) {
s.abspielen()
}
}
}
class DynamicPlaylist (songlisteParam: MutableList<Song>): Playlist(songlisteParam){
class SongNode(val song : Song, var nextSong : SongNode?)
private var first: SongNode? = null
private var last: SongNode? = null
init {
reset();
/*first = SongNode(songliste.get(0), null)
var runPointer = first
for( i in 1..songliste.size){
runPointer?.nextSong = SongNode(songliste.get(i), null)
runPointer = runPointer?.nextSong ?: runPointer
}
last = runPointer*/
}
fun add(derSongTM : Song){
last?.nextSong = SongNode(derSongTM, null)
}
fun take() : Song?{
var tmp = first
first = first?.nextSong
return tmp?.song
}
fun reset(){
first = SongNode(songliste.get(0), null)
var runPointer = first
for( i in 1..songliste.size-1){
runPointer?.nextSong = SongNode(songliste.get(i), null)
runPointer = runPointer?.nextSong ?: runPointer
}
last = runPointer
}
override fun gesamteSpieldauer() : Int{
var runPointer = first
var tmp : Int = 0
while (runPointer != null){
tmp += runPointer.song.spieldauer
runPointer = runPointer.nextSong
}
return tmp
}
override fun alleAbspielen() {
var runPointer = first
while (runPointer != null){
runPointer.song.abspielen()
runPointer = runPointer.nextSong
}
}
}
import kotlin.random.Random
class Musikverwaltung() {
val songliste: MutableList<Song> = mutableListOf<Song>()
fun hinzufuegen(song: Song) {
songliste.add(song)
}
fun suchen(begriff: String): Song?{
for(s in songliste){
if(s.search(begriff)) {
return s
}
}
return null
}
fun besterSong(): Song{
var tmp = songliste.get(0)
for(s in songliste){
if(s.bewertung > tmp.bewertung)
tmp = s
}
return tmp
}
fun zufallsPlaylist(): Playlist{
val newSongliste: MutableList<Song> = mutableListOf<Song>()
var laengePlaylist = Random.nextInt(songliste.size)
var istVorhanden = false
for(i in 0..laengePlaylist){
for (s in newSongliste){
if(songliste.get(Random.nextInt(songliste.size)) == s)
istVorhanden = true
}
if(!istVorhanden)
newSongliste.add(songliste.get(Random.nextInt(songliste.size)))
else
laengePlaylist++
}
return Playlist(newSongliste)
}
}
open class Song(val titel: String, val interpret: String, val spieldauer: Int, _bewertung: Int) {
var bewertung = _bewertung
set(value) {
if (value !in 0..100)
field = 0
else
field = value
}
open fun abspielen() {
var decke: Int
if (spieldauer % 60 == 0)
decke = spieldauer / 60
else
decke = spieldauer / 60 + 1
for (i in 1..decke)
println("Spiele: $titel von $interpret (Bewertung: $bewertung Punkte)")
}
fun change(newValue: Int) {
bewertung = newValue
}
open fun search(searchString: String): Boolean {
var istDrin = false
if (titel.contains(searchString))
istDrin = true
if (interpret.contains(searchString))
istDrin = true
return istDrin
}
}
class SongMitText(titelParam: String, interpretParam: String, spieldauerParam: Int, bewertungParam: Int, var textzeile: String) : Song(titelParam, interpretParam, spieldauerParam, bewertungParam){
override fun search(searchString: String): Boolean {
var istDrin = false
if (titel.contains(searchString))
istDrin = true
if (interpret.contains(searchString))
istDrin = true
if (textzeile.contains(searchString))
istDrin = true
return istDrin
}
}
class SongMitAutobewertung(titelParam: String, interpretParam: String, spieldauerParam: Int, bewertungParam: Int) : Song(titelParam, interpretParam, spieldauerParam, bewertungParam){
override fun abspielen() {
var decke: Int
if (spieldauer % 60 == 0)
decke = spieldauer / 60
else
decke = spieldauer / 60 + 1
bewertung++
for (i in 1..decke)
println("Spiele: $titel von $interpret (Bewertung: $bewertung Punkte)")
}
}
Comments
0 B
|👍
/👎
0 B
|👍
/👎