[Alg] lijst -> random lijsten

[Verwijderd]

Wat ik wil is een beetje vaag, maar ik heb even geen idee hoe ik het aan moet pakken. Ik heb een .txt file met daarin 1200 zinnen onder elkaar. Nou is het de bedoeling dat ik iets (geen idee waarin, hoe, wat, etc) maak dat ik vanuit deze .txt file 100 andere .txt files maak met daarin random 600 zinnen (per file, dus 100 maal een file met 600 zinnen) uit de eerste .txt file.

Hoe moet ik dit aanpakken? Ik sta open voor alle suggesties.

[Robtimus]

1) lees in een lijst alle regels
2) maak 100x een kopie van die lijst, verwijder daaruit 600 random elementen*, stop die in je tekstfile, en vernietig de kopie

* vandaar de kopie, en zonder verwijderen kun je moeilijker garanderen dat je 600 verschillende elementen hebt.

Of 2:
1) lees in een lijst alle regels
2) doe 100x: shuffle de lijst, en stop de eerste 600 regels in je tekstfile.

[djluc]

Laad al die zinnen in een array, shuffle deze, en ga die array loopen tot je er 600 hebt. Die schrijf je dus steeds weg in een file. Vervolgens shuffle je de array weer en ga je weer wegschrijven in een ander bestand.

Waarom wil je dit eigenlijk gaan doen? Ik kan hier echt geen enkele nuttige reden voor bedenken

[ Voor 20% gewijzigd door djluc op 03-04-2004 17:41 ]

[muba]

Mja, welke programmeertalen beheers je? En over welke programmeertalen beschik je / zou je kunnen beschikken op de computer waarop je dit wil gaan doen?

In elk geval:
- lees bestand in, regel voor regel
--- plaats elke regel in een nieuw item van een array (zeg, 'Regels')

- maak een array 'Bestanden' met daarin de bestandsnamen
- maak een lus die door Bestanden loopt
--- maak een lus die steeds 600 items uit Regels kiest
------ voor het wegschrijven, kies een random item uit Regels en schrijf dat naar het huidige bestand.
------ verwijder het item uit Regels en zorg dat alles weer netjes aansluit, zodat je geen gaten in Regels hebt

Beetje basis hoor, maar goed.

[djluc]

We zijn het allemaal wel aardig eens hè, maar we hebben niet allemaal zo'n mooie tree notatie zoals MUBA

Toch zit ik met een probleempje bij jouw idee MUBA: de regels array is leeg. Hoe ga je daar de 2de loop nog iets mee doen? Want hij heeft niet genoeg zinnen om ze allemaal maar 1x te gebruiken.

[Robtimus]

Daarom moet je dus eerst een kopie maken per iteratie.

[djluc]

IceManX schreef op 03 april 2004 @ 17:52:
Daarom moet je dus eerst een kopie maken per iteratie.

Waarom wil je een kopie hebben van je array? @random 600 dingen uitzoeken die nog niet in je nieuwe array staan is toch quite easy?

[Robtimus]

O ja?
Zonder verwijderen loop je het risico dat je steeds weer uit een al geselecteerde groep een nieuw element kiest. Random hoeft nml niet fair te zijn voor kleine metingen; uit de praktijk merk ik dat het voor erg kleine metingen zelfs verre van fair is. Als je een geselecteerd element verwijdert heb je daar geen last van.

Maar ja, als je verwijdert uit je enige origineel, dan is na 2 textfiles je bron uitgeput. Hence the kopie.

Al met al lijkt het steeds shuffelen mij daarom wel wat beter; je hebt hooguit 1 kopie nodig (als je je origineel ook in de originele volgorde wilt hebben, anders heb je geen kopie nodig). Vervolgens ben je wel 100x tijd kwijt aan het shuffelen, maar bij de andere optie ben je 100x 600 kwijt voor het selecteren van een random element. Zo erg is dat dus niet eens.

[Verwijderd]

Bedankt allemaal. Wat lijkt volgens jullie een makkelijke programmeertaal om dit in te doen?

[Robtimus]

Eerlijk gezegd: Python. Lists zijn primitieve typen, en het inlezen van de regels doe ik met 3 commando's:

Python:

f = open("orig.txt", "r")
lines = f.readlines()
f.close()

Kopie maken van een list is 1 commando:

Python:

copy = lines[:] # [:] to create copy, not another reference

Shuffelen:

Python:

import random

list = random.sample(list, len(list))

Met enkele commando's dus de volledige kracht.

Volledig programma:

Python:

import random

f = open("file.txt", "r")
lines = f.readlines()
f.close()

for i in range(100):
    list = random.sample(lines, 600)
    f = open("tmp" + str(i) + ".txt", "w")
    for j in list:
        f.write(j)
    f.close()

Probeer dat maar eens in een andere taal in 12 regels (10 effectief) te doen!

Edit: shufflen gaat zelfs nog gemakkelijker:

Python:

import random

random.shuffle(list)

[ Voor 61% gewijzigd door Robtimus op 03-04-2004 22:11 ]

[muba]

djluc schreef op 03 april 2004 @ 17:46:
We zijn het allemaal wel aardig eens hè, maar we hebben niet allemaal zo'n mooie tree notatie zoals MUBA

Toch zit ik met een probleempje bij jouw idee MUBA: de regels array is leeg. Hoe ga je daar de 2de loop nog iets mee doen? Want hij heeft niet genoeg zinnen om ze allemaal maar 1x te gebruiken.

Dank je, dank je

Shit, daar noem je wel ff een probleempje idd... om nou elke keer die file opnieuw in te lezen, lijkt me geen handig idee... dus zodra je de tweede loop ingaat, ff een kopietje bouwen van Regels, zeg 'Regels2' en dan voer je daar de lees/delete bewerkingen op uit.
Heeft IceManX toch gelijk.

Ennuh, andijvie2004: zoals ik al vroeg:
Mja, welke programmeertalen beheers je? En over welke programmeertalen beschik je / zou je kunnen beschikken op de computer waarop je dit wil gaan doen?

[ Voor 16% gewijzigd door muba op 03-04-2004 21:50 ]

[Soultaker]

Voor een enkele file:

code:

perl -e'@a=<>;print splice@a,int rand$#a+1,1while($i++<600);' invoer>uitvoer

En dat dan 100 keer, ofzo?

[ Voor 13% gewijzigd door Soultaker op 03-04-2004 22:21 ]

[muba]

Soultaker schreef op 03 april 2004 @ 22:18:
Voor een enkele file:

code:

perl -e'@a=<>;print splice@a,int rand$#a+1,1while($i++<600);' invoer>uitvoer

En dat dan 100 keer, ofzo?

hoezo zieke oplossing

[Robtimus]

Soultaker schreef op 03 april 2004 @ 22:18:
Voor een enkele file:

code:

perl -e'@a=<>;print splice@a,int rand$#a+1,1while($i++<600);' invoer>uitvoer

En dat dan 100 keer, ofzo?

1) ik kan die Python code ook wel op 1 regel proppen (denk ik), maar daar wordt het niet mooier van
2) dat 100x doe je natuurlijk in een loop he? 1 regel extra?

[Soultaker]

IceManX schreef op 03 april 2004 @ 22:25:
1) ik kan die Python code ook wel op 1 regel proppen (denk ik), maar daar wordt het niet mooier van

Ik denk het niet, want dan krijg je gezeik met de layout-rules voor die lusjes enzo. Python heeft trouwens wel mooie built-in syntax om te splicen.

[ Voor 10% gewijzigd door Soultaker op 03-04-2004 22:34 ]

[muba]

Hoe dan ook, dit is mogelijk in eigenlijk elke taal die:
A ) bestanden kan lezen en schrijven (javascript bijvoorbeeld valt dus af)
B ) met lijsten of arrays om kan gaan (dat zullen de meeste talen wel kunnen)
C ) op de een of andere manier een random functie heeft (ook dat zullen de meeste talen wel kunnen).

[Robtimus]

Soultaker schreef op 03 april 2004 @ 22:31:
[...]

Ik denk het niet, want dan krijg je gezeik met de layout-rules voor die lusjes enzo. Python heeft trouwens wel mooie built-in syntax om te splicen.

Klopt ja. De binnenste for-loop is geen probleem (gewoon die write direct na de : zetten), maar die buitenste loop werkt niet mee.

[_Squatt_]

IceManX schreef op 03 april 2004 @ 21:45:
Probeer dat maar eens in een andere taal in 12 regels (10 effectief) te doen!

9 in Ruby

Ruby:

class Array
    def shuffle; sort_by { rand }; end
end

File.open( 'text.txt') { |f| $lines = f.readlines }

(1...100).each { |i| 
    File.open( i.to_s + '.txt', 'w') { |f|
        f.puts( $lines.shuffle.slice(0..599))
    }
}

Ik vind het mooier dat je niet zelf f.close() hoeft aan te roepen, maar dat dat aan het eind van het block dat je meegeeft aan File.open() automatisch gebeurt. Verder verschilt het weinig van de Python code.

[Robtimus]

In Python hoeft dat ook niet, ik vind het alleen netter het wel te doen.

[WildernessChild]

Geen idee wat die Python- en Ruby-code precies doet, maar het idee dat je telkens een kopie maakt van je "bronlijst" staat me tegen.

Gebruik gewoon een boolean arraytje van 1200 vlaggetjes die aangeven of je de betreffende zin al gebruikt hebt in het huidige uitvoerbestand; en zet al die vlaggetjes terug als je aan een nieuw uitvoerbestand begint.

Is een stuk efficiënter dan telkens kopiëren.

[Robtimus]

Dit heb ik al eerder aangekaart: omdat het random is, kun je niet voorkomen dat je telkens random een al geselecteerd uitkiest. Je skipt dan wel, maar bent dus wel tijd voor niets kwijt.

De enige manier om dit te vermijden is verwijderen.

[Soultaker]

Tenminste in Python (en vast ook in een heleboel andere scripttalen) is een lijst van strings niet minder efficiënt dan een lijst van booleans. Een lijst bevat alleen references naar de objecten erin; of die objecten vervolgens strings of booleans zijn maakt niets uit. Bij het kopiëren van een lijst worden dan ook uitsluitend references gekopieerd (shallow copy en dus geen deep copy).

De voorgestelde methode van aparte lijsten met booleans en strings is dus waarschijnlijk alleen maar minder efficiënt en zeker nodeloos ingewikkeld.