fylle array med bokstaver tilfeldig

[geir_a]

Kan du prøve

 

String input=A.nextLine();

 

?

[Gnurk!]

Hjelper det hvis du skriver:

 

System.out.print(java.util.Arrays.toString(tabell));

 

Hvis du importerer java.util.* kan du sløyfe det i koden over.

importerer java.util.*

fant faktisk problemet ved flaks (woho) viser seg at scanner.next ikke fungerer til dette, du må bruke .nextLine

[Gnurk!]

ah ser du svarte rett før, jepp det var vist det, kan nok ikke nok om programering til å vite forskjellen på .next og .nextLine ennå tho :\

[Gnurk!]

da var oppgaven løst, tusen takk for all hjelpa

 

 

her er løsninga mi:

 

package minePrograms;

import java.util.*;

public class oppgave7c {

 

/**

* @param args

*/

public static void main(String[] args) {

boolean start=true;

 

while(start==true){

 

 

Scanner A=new Scanner(System.in);

String input=A.nextLine();

String[]tabell=input.split(" ");

Arrays.sort(tabell);

int i=0;

int lengde=tabell.length;

boolean check=false;

while(check==false){

System.out.print(tabell+" ");

i=i+1;

if(i==lengde){

check=true;

}

}

 

System.out.println();

}

 

}

 

 

}

[fleskesvor]

Du trenger heller ikke å bruke en int for å iterere over arrayen din:

 

for (String word : tabell) {
  // gjør et eller annet
}

[Gnurk!]

mangler nok litt info forstå NØYAKTIG hva du mente der

[hlnd]

Når du vil hente elementene i en liste, gjør du det sånn:

int[]
int i = 0;
int lengde = tabell.length;
boolean check = false;
while (check == false) {
System.out.print(tabell[i] + " ");
i = i + 1;
if (i == lengde) {
	check = true;
}
}

 

Det er fryktelig tungvint. Med foreach, som fleskesvor foreslår, trenger du bare to linjer i stedet:

 

for (int element : tabell)
System.out.print(element + " ");

 

Det å hente ut elementer fra en tabell er noe som man må gjøre så ofte at de aller fleste språk gjør dette enkelt. Oversatt til norsk, betyr syntaksen

 

for hvert heltall i tabell:
skriv ut heltallet med et mellomrom etterpå

 

 

Løste forresten oppgavene på en litt annen måte selv, du kan se om du får noe ut av det. Den første, der du skal sortere bokstaver, fungerer for vilkårlig start- og sluttbokstav, og vilkårlig lengde på det tilfeldige arrayet, mens der du skal sortere strenger får du litt mer output.

 

Tilfeldige verdier:

 

package rnd;

import java.util.Arrays;

public class MakeChars {

private char[] letters;
int lowerBound;
int upperBound;
int[] indices;

private MakeChars() {
	makeList();
	Arrays.sort(letters);
	findLetters();
	displayResults();
}


private void makeList() {
	letters = new char[50];
	lowerBound = (int) 'A';
	upperBound = (int) 'G';

	for (int i = 0; i < letters.length; i++) {
		letters[i] = (char) (lowerBound + (int) (Math.random() * (upperBound - lowerBound + 1)));	// +1 to include last element
	}
}


private void findLetters() {

	indices = new int[upperBound - lowerBound + 1];

	for (char c = (char) lowerBound; c <= (char) upperBound; c++){
		int index = Arrays.binarySearch(letters, c);
		indices[((int) c) - lowerBound] = index;
	}

}


private void displayResults() {

	// Array:
	System.out.print("Letters, sorted: [");
	for (int i = 0; i < letters.length - 1; i++) {
		System.out.print(letters[i] + " ");
	}
	System.out.println(letters[letters.length - 1] + "]");

	// Indices:
	for (int i = 0 ; i < indices.length; i++) {
		if (indices[i] >= 0)
			System.out.println("First index found by binarySearch of " 
					+ (char) (lowerBound + i)
					+ " is " + indices[i]
					);
		else
			System.out.println((char) (lowerBound + i)
					+ " was not found in the randomly generated list");
	}
}


public static void main(String[] args) {

	new MakeChars();

}


}

 

 

 

Sortere strenger:

 

package rnd;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;

public class LexicographicalOrder {

// Lists are better suited for adding elements to, and they give prettier output
private List<String> currentWords; 
private List<List<String>> inputs;

public LexicographicalOrder() {
	inputs = new LinkedList<List<String>>();

	BufferedReader reader = new BufferedReader(
			new InputStreamReader(System.in));

	while(true){
		System.out.println("Enter words separated by space to see them sorted.");
		System.out.println("Enter an empty string to terminate.");

		String input = "";
		try {
			input = reader.readLine();
		} catch (IOException e) {
			e.printStackTrace();
		}

		if (input.equals("")){
			System.out.println("You entered an empty string. Shutting down.");
			break;
		}

		currentWords = Arrays.asList(input.split(" "));
		Collections.sort(currentWords, String.CASE_INSENSITIVE_ORDER);
		// Sorts case insensitive
		// acAbC sorted is AabCc instead of ACabc

		System.out.println("You typed in the following words: ");
		System.out.println(currentWords);

		inputs.add(currentWords);

		System.out.println("\n----------\n");
	}	


}

public static void main(String[] args) {
	new LexicographicalOrder();
}

}

 

 

Ellers, om du husker å legge koden din i

med [/code] etterpå og

 foran (feil rekkefølge så du skal se taggene)

Blir det veldig mye lettere å lese for alle oss andre

Endret 27. oktober 2011 av hlnd

[Gnurk!]

hehe takk for forklaringen, skal legge koden skjult fra nå av for dere

[hlnd]

Det var egentlig

 jeg tenkte på, da får man innrykk i linjene der det skal være det og litt fargekoding av syntaks 

[Gnurk!]

ah k

kan legge til at jeg forandra litt på koden på den mellomste før jeg leverte, da search funksjonen var litt "ineffektiv" (flytte iC iD etc bak, og forandra fra =0; til =den gamle bokstaven.

package minePrograms;
import java.util.*;

public class oppgave7b {


public static void main(String[] args) {
char[] tabell=new char[7000];
char[] bokstaver={'A', 'B', 'C', 'D', 'E', 'F', 'G'};
double fix;
double fix2;
int fix3;
for (int i = 0; i < 7000; i++) {
fix=Math.random();
fix2=fix*7;
fix3=(int)fix2;
tabell[i] = bokstaver[fix3];
}

Arrays.sort(tabell);
String tabell2=new String(tabell);
int iB=0;
while(tabell[iB]!= 'B'&&tabell[iB]<7001){
iB=iB+1;
}
int iC=iB;
while(tabell[iC]!= 'C'&&tabell[iB]<7001){
iC=iC+1;
}
int iD=iC;
while(tabell[iD]!= 'D'&&tabell[iB]<7001){
iD=iD+1;
}

int iE=iD;
while(tabell[iE]!= 'E'&&tabell[iB]<7001){
iE=iE+1;
}
int iF=iE;
while(tabell[iF]!= 'F'&&tabell[iB]<7001){
iF=iF+1;
}
int iG=iF;
while(tabell[iG]!= 'G'&&tabell[iB]<7001){
iG=iG+1;
}
System.out.println(iB);
System.out.println(iC);
System.out.println(iD);
System.out.println(iE);
System.out.println(iF);
System.out.println(iG);
}



}

Endret 27. oktober 2011 av Gnurk(homesmasher)

[srbz]

Du gjør ting veldig tungvindt synes jeg. Endel unødvendige hjelpevariabler du bare oppretter for å lese/endre på dem rett etterpå.

 

I tillegg hardkoder du en telleløkke (while-løkke) for hver bokstav. Hva om du utvider til 29 bokstaver, 10 siffer og 40 spesialtegn? Mye kjekkere å ha én enkelt løkke som går igjennom alt, blir mye mer dynamisk på den måten. God kodeskikk!