import java.util.

Random; //inizializzazione random e media con funzioni

public class Main {

public static final int N = 100;

public static void main(String[] args){

int [] vett = new int [N];

int val_max = 50;
int val_min = 0;
int medianum = 0;

init(vett, val_max, val_min);

int inizio = 0;
int fine = 34;

medianum = media(vett, inizio, fine, medianum);

System.out.println("La media dei numeri della sottoporzione è : " +

medianum);

}
public static void init(int[] vett, int val_min, int val_max){

//Arrays.fill(vett, 0);

Random genre = new Random(N);

for (int i=0; i < vett.length; i++){

vett[i] = genre.nextInt((val_min - val_max) + 1);
}

}
public static int media(int []vett, int inizio, int fine, int medianum){

int cont = 0;

for(int i = inizio; i < fine; i++){

medianum += vett[i];
cont++;
}
medianum = medianum / cont;
return medianum;
}
}
___________________________________________________________________________________
__________________

#include <stdio.h> //mini calcolatrice

#include <math.h>

int sommanum(int num1, int num2, int somma){

somma = num1 + num2;
return somma;
}
 int subnum(int num1, int num2, int sub){
sub = num1 - num2;
return sub;
}

int molnum(int num1, int num2, int mol){

mol = num1 * num2;
return mol;
}

int divisnum(int num1, int num2, int divis){

divis = num1 / num2;
return divis;
}

int potenza( int num1, int num2, int pot){

pot = pow(num1, num2);
return pot;
}

int fattoriale( int num1, int fact){

while(num1 > 0){
fact *= num1;
num1--;
}
return fact;
}

int main()
{
int num1, num2 = 0;
int somma , sub, mol, divis, pot = 0;
int scelta, load = 0;
int fact = 1;

do {
printf("> Inserisci il primo numero \n");
scanf("%d",&num1);

printf("> Inserisci il secondo numero \n");

scanf("%d",&num2);

printf("> Inserisci il tipo di operazione che vuoi eseguire ( 1.+, 2.-, 3.*,
4./, 5.elevamento potenza, 6.fattoriale)\n");
scanf("%d",&scelta);

switch(scelta){
case 1:
somma = sommanum(num1, num2, somma);
printf("> La somma dei due numeri è : %d \n",somma);
break;

case 2:
sub = subnum(num1, num2, sub);
printf("> La sottrazione dei due numeri è : %d \n",sub);
break;
 case 3:
mol = molnum(num1, num2, mol);
printf("> La moltiplicazione dei due numeri è : %d \n",mol);
break;

case 4:
divis = divisnum( num1, num2, divis);
printf("> La divisione dei due numeri è : %d \n",divis);
break;

case 5:
pot = potenza( num1, num2, pot);
printf("> Il risultato dell'elevamento potenza è : %d \n",pot);
break;

case 6:
fact = fattoriale(num1, fact);
printf("> Il risultato del numero fattoriale è : %d \n",fact);
break;

default:
printf("> Operazione non riuscita \n");
break;
}
printf("> Vuoi ricominciare? (1.Ricomincia/2.Termina): ");
scanf("%d",&load);

} while(load == 1);

}
___________________________________________________________________________________
_________________

#include <stdio.h> //somma e media velori randomici

void temperaturag( int tempmax[], int tempmin[], int val, int giorno, int cont){

for(int i = 0; i < cont; i++){

printf("\nInserisci la temperatura massima del giorno %d: ",giorno);
scanf("%d",&val);
tempmax[i] += val;
val = 0;
printf("\nInserisci la temperatura minima del giorno %d: ",giorno);
scanf("%d",&val);
tempmin[i] += val;
val = 0;
giorno++;
}
}

void mediatemp( int tempmax[], int tempmin[], float media, int giorno, int cont){

giorno = 1;

for(int i = 0; i < cont; i++){

media = tempmax[i] + tempmin[i];
media = media / 2;
printf("\nMedia delle temperature del giorno %d: %f",giorno, media);
 giorno++;
media = 0;
}

#define cont 7
int main()
{
int tempmax[6];
int tempmin[6];
int giorno = 1;
int val, scelta, reload = 0;
float media = 0;

do{

for(int i = 0; i < cont; i++){

tempmax[i] = 0;
tempmin[i] = 0;
}

giorno = 1;

temperaturag(tempmax, tempmin, val, giorno, cont);

printf("\nQuale gruppo di temperature vuoi visualizzare? (1.Temperature

massime, 2.Temperature minime)");
scanf("%d",&scelta);

giorno = 1;

switch(scelta){
case 1:

for(int k = 0; k < cont; k++){

printf("\nTemperature massima del giorno %d: %d
",giorno,tempmax[k]);
giorno++;
}
break;

case 2:

for(int j = 0; j < cont; j++){

printf("\nTemperature massima del giorno %d: %d
",giorno,tempmin[j]);
giorno++;
}
break;

default:
printf("\nOperazione non riuscita");
break;
}

printf("\n| Media delle temperature di ogni giorno della settimata |\n");

mediatemp(tempmax, tempmin, media, giorno, cont);
 printf("\nVuoi ripetere il programma? (1.Si, 2.No): ");
scanf("%d",&reload);

}while(reload == 1);

}
___________________________________________________________________________________
____________
bubble sort

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>

void main()
{

int myArray [200];

int i, j, numero, temp;
srand(time(NULL));

printf("\n Inserire il numero di elementi massimi (MAX 200): ");

scanf("%d", &numero);

while(numero > 50)

{
printf("Numero inserito maggiore di 200, inserirne un'altro: ");
scanf("%d", &numero);
}

for(i = 0; i < numero; i++)

{
myArray[i]=0;
}

printf("\n Array: ");

for(i = 0; i < numero; i++)

{
myArray[i] = rand()%100;
printf(" %d ", myArray[i]);
}

for (i = 0; i < numero; i++)

{
for (j = 0; j < numero - i - 1; j++)
{
if (myArray[j] > myArray[j + 1])
{
temp = myArray[j];
myArray[j] = myArray[j + 1];
myArray[j + 1] = temp;
}
}
}
 printf("\n Array in ordine crescente: ");

for(i = 0; i < numero; i++)

{
printf(" %d ", myArray[i]);
}

}
___________________________________________________________________________________
_____________
|java|

import java.util.Random; //indovina il numero

import java.util.Scanner;
/*
public class Main
{
public static void main(String[] args) {

int scelta = 0;
int tent = 0;
int max = 10;
int min = 1;

Random random = new Random();

Scanner input = new Scanner(System.in);

System.out.print("\n|> |Generazione del numero casuale...|\n");

int n = random.nextInt((max - min) + 1);

while(tent < 2){

System.out.print("\n|> |Indovina il numero generato, compreso tra 1

e 9| ");
scelta = input.nextInt();

if(scelta == n){
System.out.print("\n|> |Numero indovinato| ");

}else if(scelta != n){

System.out.print("\n|> |Numero non indovinato| ");

}
tent++;
if(tent == 2){
System.out.print("\n|> |Tentativi finiti| ");
break;
}
}

}
}
*/

public class Main //valori coppie random

{
public static final int limit = 100;
 public static void main(String[] args) {
int n1 = 0;
int n2 = 0;
int min = 1;
int max = 7;
int couple1 = 0;
int couple2 = 0;
int couple3 = 0;
int couple4 = 0;
int couple5 = 0;
int couple6 = 0;

Random random = new Random();

System.out.print("\n|> |Generazione delle coppie doi numeri...| ");

for(int i = 0; i < limit; i++){

n1 = random.nextInt((max - min) + 1);

n2 = random.nextInt((max - min) + 1);

System.out.print("\n " + n1 + " - " + n2);

if(n1 == 1 && n2 == 1){

couple1++;
}else if(n1 == 2 && n2 == 2){
couple2++;
}else if(n1 == 3 && n2 == 3){
couple3++;
}else if(n1 == 4 && n2 == 4){
couple4++;
}else if(n1 == 5 && n2 == 5){
couple5++;
}else if(n1 == 6 && n2 == 6){
couple6++;
}
}
System.out.print("\n|> |Il numero delle coppie 1 - 1 generate sono: " +
couple1);
System.out.print("\n|> |Il numero delle coppie 2 - 2 generate sono: " +
couple2);
System.out.print("\n|> |Il numero delle coppie 3 - 3 generate sono: " +
couple3);
System.out.print("\n|> |Il numero delle coppie 4 - 4 generate sono: " +
couple4);
System.out.print("\n|> |Il numero delle coppie 5 - 5 generate sono: " +
couple5);
System.out.print("\n|> |Il numero delle coppie 6 - 6 generate sono: " +
couple6);
}
}

___________________________________________________________________________________
_______________

import java.util.Random; //media, valore min, valore max, sottoporzione, limitatore

array, ordina asc disc, inverti
import java.util.Scanner;
public class JavaApplication5 {

public static final String RESET = "\u001B[0m";

public static final String RED = "\u001B[31m";
public static final String GREEN = "\u001B[32m";

public static final int N = 100;

public static void main(String[] args){

int [] vett = new int [N];

int [] vettordinato = new int [N];
int val_max = 50;
int val_min = 0;
float medianum = 0;
int pos = 0;
int valmin = 0;
int valmax = 0;
int scelta = 0;
int reload = 0;
int valore = 0;
int pes = 0;
int inizio = 1;
int fine = 10;
int ordine = 0;
boolean verso = false;

do {
System.out.println(RED + "
System.out.println("|> 1) |Inizializza il vettore||Necessario per
utilizzare gli altri comandi|");
System.out.println("|> 2)
System.out.println("|> 3)
System.out.println("|> 4)
System.out.println("|> 5)
ascendente o discendente|");
System.out.println("|> 6)
System.out.println("|> 7)
System.out.println("|> 8)
System.out.println("|> 9)
|MENU| " + RESET);
|Fai la media della sottoporzione|");
|Trova il valore minimo|");
|Trova il valore massimo|");
|Controlla se il vettore è in ordine
|Ordina il vettore|");
|Inverti l'ordine delle celle del vettore|");
|Ricerca di un valore|");
|Ricerca dicotomica|");

Scanner input = new Scanner(System.in);

scelta = input.nextInt();
switch (scelta){
case 1:
init(vett, val_max, val_min);
break;
case 2:
System.out.println("Inserisci l'inizio della sottoporzione: ");
inizio = input.nextInt();
System.out.println("Inserisci la fine della sottoporzione: ");
fine = input.nextInt();

medianum = media(vett, inizio, fine, medianum);

System.out.println("La media dei numeri della sottoporzione è :

" + medianum);
 break;
case 3:
valminimo(vett, valmin, pos);
break;
case 4:
valmassimo(vett, valmax, pos);
break;
case 5:
verso = ordinato(vett, verso);
break;
case 6:
ordina(vett, ordine);
break;
case 7:
inverti(vett, verso);
break;
case 8:
System.out.println("|> |Inserisci il valore che vuoi
trovare|");
valore = input.nextInt();

pes = ricerca(vett[], valore, pes);

System.out.print("\nIl valore ricercato è alla posizione " +
pes);
break;
case 9:
ricercadicotomica(vett[], valore, pes);
System.out.print("\nIl valore ricercato è alla posizione " +
pes);
break;
default:
System.out.println(RED + "|> |Operazione non riuscita|" +
RESET);
break;
}
System.out.println(GREEN + "\n|> Vuoi tornare al menù? |1.Torna al
menù||2.Termina|" + RESET);
reload = input.nextInt();
}while(reload == 1);

public static void init(int[] vett, int val_min, int val_max){

Random genre = new Random(N);

for (int i = 0; i < vett.length; i++){

vett[i] = genre.nextInt((val_min - val_max) + 1);

System.out.print(vett[i] + " ");
}
}

public static float media(int []vett, int inizio, int fine, float medianum){

int cont = 0;
medianum = 0;

for(int i = inizio; i < fine; i++){

 medianum += vett[i];
cont++;
}
medianum = medianum / cont;
return medianum;
}

public static void valminimo(int []vett, int valmin, int pos){

valmin = vett[0];

for(int i = 1; i < vett.length - 1; i++){

if(valmin > vett[i]){

valmin = vett[i];
pos = i;
}
}
System.out.println("Il numero minimo è: " + valmin + " alla posizione: " +
pos);
}

public static void valmassimo(int []vett, int valmax, int pos){

valmax = vett[0];

for(int i = 1; i < vett.length - 1; i++){

if(valmax < vett[i]){

valmax = vett[i];
pos = i;
}
}
System.out.println("Il numero massimo è: " + valmax + " alla posizione: " +
pos);
}

public static boolean ordinato(int vett[], boolean verso){

int limitA = 0;
int limitD = 0;

for(int i = 0; i < vett.length - 1; i++){

if(vett[i] < vett[i + 1]){

limitA++;
if(limitA == vett.length - 1){
verso = true;
}
}
if(vett[i] > vett[i + 1]){

limitD++;
if(limitD == vett.length - 1){
verso = true;
}
}
 if(verso == true){
System.out.println("|> |Il vettore è ordinato|");
}else if(verso == false){
System.out.println("Il vettore non è ordinato");
}
return verso;
}

public static void ordina(int vett[], int ordine){

int ind = 0;

Scanner in = new Scanner(System.in);

System.out.println("\nCome vuoi ordinare il vettore? |1.Ordine ascendente||
2.Ordine discendente|");
ordine = in.nextInt();

if(ordine == 1){

for (int i = 0; i < vett.length; i++)

{
for (int k = 0; k < vett.length - i - 1; k++)
{
if (vett[k] > vett[k + 1])
{
ind = vett[k];
vett[k] = vett[k + 1];
vett[k + 1] = ind;
}
}
}

for(int k = 0; k < vett.length; k++){

System.out.print(vett[k] + " ");
}

}else if(ordine == 2){

for (int i = 0; i < vett.length; i++)

{
for (int k = 0; k < vett.length - i - 1; k++)
{
if (vett[k] < vett[k + 1])
{
ind = vett[k];
vett[k] = vett[k + 1];
vett[k + 1] = ind;
}
}
}

for(int y = 0; y < vett.length; y++){

System.out.print(vett[y] + " ");
}

}else if(ordine != 1 && ordine != 2){

System.out.println(RED + "\n|> |Operazione non riuscita|" + RESET);
}
}
 public static void inverti(int vett[], boolean verso){

int var = 0;
int lim = vett.length - 1;

for (int i = 0; i < vett.length - 1; i++){ //inverto i valori del vettore

var = vett[i];
vett[i] = vett[lim];
vett[lim] = var;
lim--;

for(int i = 0; i < vett.length - 1; i++){

System.out.print(vett[i] + " ");
}

verso = false;
}

public static int ricerca(int vett[], int valore, int pes){

for(int i = 0; i < vett.length - 1; i++){

if(valore == vett[i]){
System.out.print("\n|> |Valore trovato|");
pes = i; //memorizzo la posizione
}
}
return pes;
}

public static void ricercadicotomica(int vett[], int valore, int pes){

int right = vett.length / 2;

int left = 0;

for(int i = 0; i < vett.length / 2; i++){

if(valore == vett[i] && i < right){
pes = i;
}

}
}