16 svar · 726 visningar · startad av Ceeron
Pillar på en sak o vill se hur ni andra med lite mer erfarenhet skulle göra detta:
Skapa en lottorad som genererar 7st olika tal mellan 1 o 35 (listas i storleksordning).
Med hjälp av en förbestämd lottorad kunna jämföra med den genererade samt visa antal rätt.
Tack
Jag skulle slumpa fram ett tal inom intervallet sju gånger (eller fler om något nummer inträffar fler ggr än 1) och slutligen sortera med quicksort.
Kod? =)
PSEUDOKOD "rätt upp och ned:"
The Lottoslumper:
{vars }
lottoArr[7] : integer
i : integer
j : integer
f : boolean
lottonum : integer
CODE BEGIN
i <- 0
WHILE i < 7 DO
j <- 0
f <- 1
lottonum <- RANDOM(0-35)
WHILE j < i DO
IF lottonum EQUALS lottoArr[j] AND i > 0 THEN
i <- i - 1
f <- 0
j <- j + 1
IF f DO
lottoArr[i] <- lottnum
i <- i + 1
QUICKSORT(lottoArr)
CODE END
Konverteringen till java får du göra själv :p
*hehe*
PeW... Den där var elak... Kan du inte vara snäll och hjälpa gossen med hans skoluppgifer... ;-)
Kanske elakt, vad vet jag? ;)
Men jag har iaf inte lust att presentera komplett färdiga lösningar. Däremot diskuterar jag gärna och kommer med förslag.
Kan man grundläggande programmering är det ju inte svårt att göra om ovan kod till valfritt språk :)
ok =b ska ta o försöka göra om det nån da till skolan som sagt ;)
Postar igen om jag needar hjälp =b
Har suttit o pillat lite o det ordnade sig typ ;)
Men vet inte vad "quicksort" e. Skulle nån kunna visa?
Sedan ska jag bara kolla hur många rätt man har men det e väl samma princip som föregående loop? ;)
public class inlamn {
public static void main(String[] args) {
int i, j, lottonummer; //Deklarerar i, j & lottnummer
int minArr[] = new int[7]; //Skapar Arrayen minArr med 7st platser, samt ger dom värden
minArr[0] = 11;
minArr[1] = 25;
minArr[2] = 8;
minArr[3] = 2;
minArr[4] = 31;
minArr[5] = 23;
minArr[6] = 17;
int lottoArr[] = new int[7]; //Skapar Arrayen lottoArr med 7st platser
System.out.print("Din rad: ");
i = 0;
while ( i < minArr.length )
{
System.out.print(minArr[i] + ", ");
i++;
}
System.out.println();
System.out.print("Den genererade lottoraden: ");
i = 0;
while ( i < lottoArr.length ) //Kör medans i är mindre än lottArr som är 7
{
j = 0; // Ge j värdet 0
lottonummer = 1 + (int)(35 * Math.random()); //Slumpa fram ett nummer mellan 1 & 35
while ( j < i && i > 0 ) //Kör medans j är mindre än i och i är större än 0
{
if ( lottoArr[j] == lottonummer ) //Om lottoArr med värdet för i är samma som lottnummer
{
lottonummer = 1 + (int)(35 * Math.random()); //Slumpa fram ett nummer mellan 1 & 35
if ( j > 0 )
{
j--; //Sänker värdet på j med 1
}
}
else
{
j++; //Höjer värdet på j med 1
}
}
lottoArr[i] = lottonummer; //Ger lottoArr med värdet för i värdet från lottonummer
System.out.print(lottoArr[i] + ", "); //Skriver ut lottoArr med värdet för i
i++; //Höjer värdet på i med 1
}
System.out.println();
System.out.print("Du hade alltsa: ");
//Slut på filen
}}
Tack på förhand ;)
Om du kollar lite i java api'ets dokumentation ( http://java.sun.com/j2se/1.4.1/docs/api/ ) och då under java.util / Class arrays så hittar du en drös med sort(..) . Dessa baseras på quicksort algoritmen.
Nu tror jag iofs att pedagogiken ligger i att använda Comparable och skriva en egen sort-funktion... :-)
/Lime
Förstår mig inte på det där med sort pga. att man e n00b på det hela ;)
Hittade nåt hur man sorterade typ men hajjade inte ett skit hur man fixade det...
Nån som kan hjälpa en stackare? ;)
public class inlamn {
public static void main(String[] args) {
int i, j, lottonummer; //Deklarerar i, j & lottnummer
int minArr[] = new int[7]; //Skapar Arrayen minArr med 7st platser, samt ger dom värden
minArr[0] = 11;
minArr[1] = 25;
minArr[2] = 8;
minArr[3] = 2;
minArr[4] = 31;
minArr[5] = 23;
minArr[6] = 17;
int lottoArr[] = new int[7]; //Skapar Arrayen lottoArr med 7st platser
System.out.print("Din rad: ");
i = 0;
while ( i < minArr.length )
{
System.out.print(minArr[i] + ", ");
i++;
}
System.out.println();
System.out.print("Den genererade lottoraden: ");
i = 0;
while ( i < lottoArr.length ) //Kör medans i är mindre än lottArr som är 7
{
j = 0; // Ge j värdet 0
lottonummer = 1 + (int)(35 * Math.random()); //Slumpa fram ett nummer mellan 1 & 35
while ( j < i && i > 0 ) //Kör medans j är mindre än i och i är större än 0
{
if ( lottoArr[j] == lottonummer ) //Om lottoArr med värdet för i är samma som lottnummer
{
lottonummer = 1 + (int)(35 * Math.random()); //Slumpa fram ett nummer mellan 1 & 35
if ( j > 0 )
{
j--; //Sänker värdet på j med 1
}
}
else
{
j++; //Höjer värdet på j med 1
}
}
lottoArr[i] = lottonummer; //Ger lottoArr med värdet för i värdet från lottonummer
System.out.print(lottoArr[i] + ", "); //Skriver ut lottoArr med värdet för i
i++; //Höjer värdet på i med 1
}
System.out.println();
System.out.print("Du hade alltsa: ");
//Slut på filen
}
}
Alltså vill sortera både lottoArr & minArr
Ponera att du hade lottoraden som bollar framför dig... hur skulle du sortera dom personligen?
Kolla också på http://ciips.ee.uwa.edu.au/~morris/Year2/PLDS210/qsort.html så får du en bra genomgång på QuicSort...
/Lime
QuickSort
Hehe... bara för att jag har tråkigt idag så skrev jag ihop en QuickSort... Det finns ett liiiitet fel med den... ;-)
QuickSort.java
package lime.util;
import java.util.Vector;
/**
* QuickSort.java by Lime, 19 Mars 2003
*
* Algorithm designed by prof C. A. R. Hoare, 1962
*
* Rekursiv QuickSort, sorterar (delar av) en Vector genom att
* 1. Välja en 'pivot' (center på svenska), ett element att jämföra med
* 2. dela vectorn i två delar:
* - mindre än pivot
* - större än eller lika med pivot
* Ett element som är lika med pivot kan hamna i vilken del som helst.
* 3 Sortera delarna rekursivt tills det bara finns ett element kvar.
*/
public class QuickSort{
public void quickSort(Vector elements)
{ if (! elements.isEmpty())
{ this.quickSort(elements, 0, elements.size()-1);
}
}
private void quickSort(Vector elements, int lowIndex, int highIndex)
{ int lowToHighIndex;
int highToLowIndex;
int pivotIndex;
String pivotValue; // Har använt strängar i den här... Går att göra på annat sätt.
String lowToHighValue;
String highToLowValue;
String parking;
int newLowIndex;
int newHighIndex;
int compareResult;
lowToHighIndex = lowIndex;
highToLowIndex = highIndex;
/**
* Välj en pivot, kom i håg dess värde
* Inget specielt görs med pivot elementet.
* Den kommer att hanteras som vilket annat element som helst
*/
pivotIndex = (lowToHighIndex + highToLowIndex) / 2;
pivotValue = (String)elements.elementAt(pivotIndex);
/**
* Dela upp Vectorn i två delar.
*
* Den lägre delen blir lowIndex - newHighIndex,
* och innehåller element <= pivot värdet
*
* Den högre delen blir newLowIndex - highIndex,
* och innehåller element >= pivot värdet.
*/
newLowIndex = highIndex + 1;
newHighIndex = lowIndex - 1;
// loopa tills low möter hight
while ((newHighIndex + 1) < newLowIndex) // loopa till delen är klar
{ // loopa från low till high för att hitta element att swapa
lowToHighValue = (String)elements.elementAt(lowToHighIndex);
while (lowToHighIndex < newLowIndex
& lowToHighValue.compareTo(pivotValue)<0 )
{ newHighIndex = lowToHighIndex; // lägg till element till lägre delen
lowToHighIndex ++;
lowToHighValue = (String)elements.elementAt(lowToHighIndex);
}
// loopa från high to low för att hitta element att swapa.
highToLowValue = (String)elements.elementAt(highToLowIndex);
while (newHighIndex <= highToLowIndex
& (highToLowValue.compareTo(pivotValue)>0)
)
{ newLowIndex = highToLowIndex; // add element to higher part
highToLowIndex --;
highToLowValue = (String)elements.elementAt(highToLowIndex);
}
// swapa om det behövs.
if (lowToHighIndex == highToLowIndex)
{ newHighIndex = lowToHighIndex;
}
else if (lowToHighIndex < highToLowIndex) // inte sista elementet ännu...
{ compareResult = lowToHighValue.compareTo(highToLowValue);
if (compareResult >= 0) // low >= high, swapa, även om de är lika.
{ parking = lowToHighValue;
elements.setElementAt(highToLowValue, lowToHighIndex);
elements.setElementAt(parking, highToLowIndex);
newLowIndex = highToLowIndex;
newHighIndex = lowToHighIndex;
lowToHighIndex ++;
highToLowIndex --;
}
}
}
// Fortsätt rekursivt för alla delar som har mer än ett element.
if (lowIndex < newHighIndex)
{ this.quickSort(elements, lowIndex, newHighIndex); // sortera lägre delen
}
if (newLowIndex < highIndex)
{ this.quickSort(elements, newLowIndex, highIndex); // sortera högre delen
}
}
}
Testklass.
import javax.swing.*;
import java.awt.*;
import java.awt.image.*;
import java.util.*;
/**
*
* @author Lime
*/
public class TestMain extends javax.swing.JFrame {
Vector sv = new Vector();
/** Creates new form TestMain */
public TestMain() {
initComponents();
//JImageTextArea jita = new JImageTextArea("images/boat.gif");
//jita.setResize(true);
//this.getContentPane().add(jita);
sv.add("29");
sv.add("1");
sv.add("1000");
sv.add("40");
sv.add("91000");
sv.add("10000001");
sv.add("8000");
sv.add("14");
sv.add("101");
sv.add("12");
sv.add("14");
sv.add("1000");
sv.add("2");
jLabel1.setText(printVector(sv));
setSize(400,400);
}
/** This method is called from within the constructor to
* initialize the form.
* WARNING: Do NOT modify this code. The content of this method is
* always regenerated by the Form Editor.
*/
private void initComponents() {
java.awt.GridBagConstraints gridBagConstraints;
jButton5 = new javax.swing.JButton();
jLabel1 = new javax.swing.JLabel();
getContentPane().setLayout(new java.awt.GridBagLayout());
setTitle("MainWindow");
addWindowListener(new java.awt.event.WindowAdapter() {
public void windowClosing(java.awt.event.WindowEvent evt) {
exitForm(evt);
}
});
jButton5.setText("Sortera");
jButton5.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton5ActionPerformed(evt);
}
});
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 1;
gridBagConstraints.gridwidth = 8;
gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
gridBagConstraints.insets = new java.awt.Insets(10, 10, 10, 10);
gridBagConstraints.weightx = 1.0;
getContentPane().add(jButton5, gridBagConstraints);
jLabel1.setText("jLabel1");
getContentPane().add(jLabel1, new java.awt.GridBagConstraints());
pack();
}
private void jButton5ActionPerformed(java.awt.event.ActionEvent evt) {
// Add your handling code here:
lime.util.QuickSort qs = new lime.util.QuickSort();
qs.quickSort(sv);
jLabel1.setText(printVector(sv));
}
private String printVector(Vector v){
StringBuffer sb = new StringBuffer();
ListIterator iter = v.listIterator();
while(iter.hasNext()){
if (sb.toString().trim() != "")
sb.append(":");
sb.append((String) iter.next());
}
return sb.toString();
}
/** Exit the Application */
private void exitForm(java.awt.event.WindowEvent evt) {
System.exit(0);
}
/** Bla Bla
* @param args the command line arguments
*/
public static void main(String args[]) {
new TestMain().show();
}
// Variables declaration - do not modify
private javax.swing.JLabel jLabel1;
private javax.swing.JButton jButton5;
// End of variables declaration
}
Nu är jag bra snäll....
/Lime
En annan, inte fullt så lång variant:
//////////////////////////
// ---- quickSort
public void qsort(int[] arr){
quickSort(arr,0,arr.length-1);
}
private void quickSort(int[] arr,int l,int r){
if(r-l > 1){
int p = partion(arr,l,r);
quickSort(arr,l,p - 1);
quickSort(arr,p + 1, r);
}
}
private int partion(int[] arr,int l,int r){
int mid = l + (r - l) / 2;
swap(arr,l,mid);
int p = l;
for(int k = l + 1; k <= r; k++){
if(arr[k]<arr[l])swap(arr,++p,k);
}
swap(arr,p,l);
return p;
}
private void swap(int[] arr,int a,int b){
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
Tur att mitt skolprojekt är frivilligt annars hade det inte varit ngn match! Har Ni som kan Java några bra siter på lager, om Java programering som är grundläggande + gärna på svenska? :stud
Nope... Alla som är riktigt bra är på engelska.
Jag använder mig väldigt mycket av https://www.javasoft.com och deras Forum + tutorials.
Sedan är Bruce Eckels gratisbok "Thinking i Java, 3rd Edt" väldigt bra. Och nerladdningsbar. Finns på http://www.mindview.net/Books/TIJ/
/Lime
