L'ideale sarebbe usando semplici arraypuoi utilizzare le collection? come ArrayList, oppure sei costretto ad usare un semplice array?
Ok grazie intanto, ci provo e ti faccio sapereVa bene comunque è molto semplice, se non hai vincoli di complessità temporale, prendi il primo elemento e cerchi le sue occorrenze nell'array restante se sono >= 10 stampi il numero altrimenti no, prendi il secondo elemento e fai la stessa cosa e così via. Ovviamente questa è la modalità semplice, non ti scrivo il codice in java o in pseudocodice perché non avrebbe senso, ora che ti ho indirizzato prova a farlo tu.
Perchè >= 10?Va bene comunque è molto semplice, se non hai vincoli di complessità temporale, prendi il primo elemento e cerchi le sue occorrenze nell'array restante se sono >= 10 stampi il numero altrimenti no, prendi il secondo elemento e fai la stessa cosa e così via. Ovviamente questa è la modalità semplice, non ti scrivo il codice in java o in pseudocodice perché non avrebbe senso, ora che ti ho indirizzato prova a farlo tu.
ho riletto il testo, hai ragione ho sbagliato, pensavo che volesse tutti i numeri con minimo 10 occorrenze.l'ideale sarebbe creare o avere una struttura con 2 campi uno chiave e uno che conta le frequenze, alla fine ti stampi i 10 coi valori più grandi facendo un semplice ordinamento discendente.Usi un array di supporto di
Perchè >= 10?
Quindi creo una funzione che conta le occorrenze di ogni numero, poi le posso memorizzare in un array, lo ordino e stampo le prime 10? Un'altra domanda.ho riletto il testo, hai ragione ho sbagliato, pensavo che volesse tutti i numeri con minimo 10 occorrenze.l'ideale sarebbe creare o avere una struttura con 2 campi uno chiave e uno che conta le frequenze, alla fine ti stampi i 10 coi valori più grandi facendo un semplice ordinamento discendente.
Se ordini l'array da 100 ( metodo sort ), riduci la complessità della ricerca da O(n! (mi pare :asd:)) a O(n+ costo per ordinarlo). E sei sicuro di non avere ripetizioni.Quindi creo una funzione che conta le occorrenze di ogni numero, poi le posso memorizzare in un array, lo ordino e stampo le prime 10? Un'altra domanda.
Se ad esempio ho {12,30,2,30,.....}
conto l'occorrenza del primo 30 e la inserisco nell'array, poi quando la chiave della ricerca sarà il secondo 30, rischio di ripeterlo 2 volte nell'output? Non so se si è capito spero di si.
O(n!) eh la madonna ahahahha no al massimo sarebbe O(n^2)Se ordini l'array da 100 ( metodo sort ), riduci la complessità della ricerca da O(n! (mi pare :asd:)) a O(n+ costo per ordinarlo). E sei sicuro di non avere ripetizioni.
Ovviamente l'algoritmo funzionerà cosi: inizi con i = 0, finchè l'== è vero vai avanti e incrementi il contatore. Appena diventa !=, salvi i valori fin qui calcolati e il valore da confrontare sarà l'i attuale( ovvero il primo numero != da quello precedente ) con i successivi
void SortOccorrenze(Coppia arr[]) {
int n = arr.length;
for (int i = 1; i < n; ++i) {
int key = arr[i].occorrenze;
int j = i - 1;
while (j >= 0 && arr[j].occorrenze> key) {
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1].occorrenze= key;
}
}
for(int i=0;i<array.length;i++) bucket[array[i]]++;
import java.util.ArrayList;
import java.util.Collections;
public class test {
public static void main(String[] args) {
// TODO Auto-generated method stub
int [] a = new int [100];
System.out.println("Questi sono gli elementi:\n");
for (int i=0;i<100;i++)
{
a[i]=((int)(Math.random()*30+1));
System.out.println(a[i]);
}
System.out.println("Questi sono gli elementi ordinati:\n");
OrdinamentoAndMax o = new OrdinamentoAndMax();
int[] b = o.ordinamento(a);
System.out.println();
for (int i=0;i<100;i++)
System.out.println(b[i]);
System.out.println("Questi sono le coppie disordinate, con il loro relativo valore di occorrenza \n");
ArrayList <Coppia> c = o.occorrenze(b);
for(int i=0; i<c.size();i++)
{
int k = c.get(i).getChiave();
int v = c.get(i).getValore(k);
System.out.println(k+" , "+v);
}
System.out.println("Queste sono le coppie ordinate in base al valore di occorrenza");
Collections.sort(c,new SimpleComparator());
for(int i=0; i<c.size();i++)
{
int k = c.get(i).getChiave();
int v = c.get(i).getValore(k);
System.out.println(k+" , "+v);
}
System.out.println("Questi sono i primi 10 valori con maggiore occorrenza \n");
int j=c.size()-1;
while(j>=c.size()-10)
{
System.out.println(c.get(j).getChiave());
j--;
}
//questo è opzionale,
//stampo gli elementi che hanno la stessa occorrenza del decimo
while(j>0 && c.get(j).getValore()== c.get(j+1).getValore())
{
System.out.println(c.get(j).getChiave());
j--;
}
}
}
public class Coppia
{
private int k;
private int v;
public Coppia( int k , int v)
{
this.k=k;
this.v=v;
}
public void setCoppia(int chiave, int valore)
{
k=chiave;
v=valore;
}
public int getValore(int k)
{
return v;
}
public int getChiave()
{
return k;
}
public int getValore()
{
return v;
}
}
import java.util.ArrayList;
import java.util.Arrays;
public class OrdinamentoAndMax
{
private int a[];
public void inizializzazione( int b[])
{
int n = b.length;
a = new int [n];
for(int i=0;i<n;i++)
{
a[i]=b[i];
}
}
public int [] ordinamento (int b[])
{
Arrays.sort(b);
return b;
}
public ArrayList<Coppia> occorrenze (int b[])
{
ArrayList<Coppia> c = new ArrayList<Coppia> ();
for(int i=0;i<b.length;i++)
{
int j=i;
int key=b[i];
int count=0;
while((j+count)<b.length && key==b[j+count])
{
count++;
}
Coppia cp = new Coppia(key,count);
c.add(cp);
i=i+count-1;
}
return c;
}
}
import java.util.Comparator;
public class SimpleComparator implements Comparator<Coppia>
{
@Override
public int compare(Coppia a, Coppia b) {
// TODO Auto-generated method stub
Integer v1=a.getValore();
Integer v2=b.getValore();
return v1.compareTo(v2);
}
}