Java / Processing: Anzahl der Ziffern der kürzesten Zahl aus einem Array zurückliefern?

Hallo,

ich würde gern die Anzahl der Ziffern der kürzesten Zahl aus einem Array zurückliefern. Ich bin bisher soweit gekommen:

int findLow(int[] zahlen) {
  int min = 0;

  for (int i = 0; i < zahlen.length; i++) {
    if (zahlen < zahlen[min])
      min = i;
  }

  return min;
}

Aber das stimmt noch nicht so ganz.

3 Antworten

daCypher

Von gutefrage auf Grund seines Wissens auf einem Fachgebiet ausgezeichneter Nutzer

Computer

09.12.2020, 13:37

Es gibt wie immer verschiedene Wege, das Ziel zu erreichen. Ich hab dir mal eine Auswahl aus acht Funktionen gebaut. Kommentare im Code.

import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.function.ToIntFunction;

public class MinLen {
	public static void main(String[] args) {
		// Testroutine. Die Umwandlungen passieren in den Methoden unten.
		
		int[][] testCases = new int[][]{
				// Nur positiv
				{126425, 12345, 123, 12, 112},
				
				// positiv und negativ
				{126425, 12345, 123, 12, 112, -126425, -12345, -123, -12, -112},
				
				// positiv und negativ (kürzere Negativzahlen)
				{123, -12, 456, -45}
		};
		
		// Liste aller Funktionen erstellen
		Map<String, ToIntFunction<int[]>> functions = new LinkedHashMap<>();
		functions.put("findLow1", MinLen::findLow1);
		functions.put("findLow1s", MinLen::findLow1s);
		functions.put("findLow2", MinLen::findLow2);
		functions.put("findLow2s", MinLen::findLow2s);
		functions.put("findLow3", MinLen::findLow3);
		functions.put("findLow3s", MinLen::findLow3s);
		functions.put("findLow4", MinLen::findLow4);
		functions.put("findLow4s", MinLen::findLow4s);
		
		// Jede Testreihe mit jeder Funktion laufen lassen.
		for (int[] testCase: testCases) {
			System.out.println("Testzahlen: " + Arrays.toString(testCase));
			functions.forEach((name, function) -> System.out.println(name + ": " + function.applyAsInt(testCase)));
			System.out.println();
		}
	}
	
	private static int findLow1(int[] input) {
		// kleinste Zahl finden und davon die Länge ermitteln
		// Achtung: Bei negativen Zahlen wird die längste gefunden,
		// also z.B bei [1,14,-750] ist das Ergebnis 4 für "-750"
		
		// Variable zur Suche nach der kleinsten Zahl erzeugen
		// Startwert: Integer.MAX_VALUE (also die größte Zahl, die als int darstellbar ist)
		int kleinsteZahl = Integer.MAX_VALUE;
		
		// Alle Zahlen in der Liste durchgehen
		for (int zahl: input) {
			// falls die aktuelle Zahl kleiner als die bisherige kleinste Zahl ist,
			// kleinsteZahl auf zahl setzen.
			if (zahl < kleinsteZahl) {
				kleinsteZahl = zahl;
			}
			
			// Alternativ: kleinsteZahl = Math.min(kleinsteZahl, zahl);
			// Also "setze kleinsteZahl auf das kleinere aus kleinsteZahl und zahl
		}
		
		// Länge der kleinsten Zahl zurückgeben
		return Integer.toString(kleinsteZahl).length();
	}
	
	private static int findLow1s(int[] input) {
		// findLow1 als Stream
		return Integer.toString(Arrays.stream(input).min().getAsInt()).length();
	}
	
	private static int findLow2(int[] input) {
		// kleinsten Absolutwert finden und davon die Länge ermitteln
		// Fast das Gleiche, wie findLow1, nur dass bei negativen Werten das Minus abgeschnitten wird
		
		// Variable zur Suche nach der kleinsten Zahl erzeugen
		// Startwert: Integer.MAX_VALUE (also die größte Zahl, die als int darstellbar ist)
		int kleinsteZahl = Integer.MAX_VALUE;
		
		// Alle Zahlen in der Liste durchgehen
		for (int zahl: input) {
			// falls die aktuelle Zahl kleiner als die bisherige kleinste Zahl ist,
			// kleinsteZahl auf zahl setzen.
			if (Math.abs(zahl) < kleinsteZahl) {
				kleinsteZahl = Math.abs(zahl);
			}
			
			// Alternativ: kleinsteZahl = Math.min(kleinsteZahl, Math.abs(zahl));
			// Also "setze kleinsteZahl auf das kleinere aus kleinsteZahl und Math.abs(zahl)
		}
		
		// Länge der kleinsten Zahl zurückgeben
		return Integer.toString(kleinsteZahl).length();
	}
	
	private static int findLow2s(int[] input) {
		// findLow2 als Stream
		// (hier werden erst alle Werte in ihren Absolutwert umgewandelt und dann erst der Kleinste gesucht.)
		return Integer.toString(Arrays.stream(input).map(Math::abs).min().getAsInt()).length();
	}
	
	private static int findLow3(int[] input) {
		// tatsächlich die Länge der Zahlen vergleichen
		// Achtung: Bei negativen Zahlen wird das minus zur Länge mitgezählt, 
		// also z.B. -123 hat die Länge 4.
		
		// Variable zur Suche nach der kürzesten Zahl erzeugen
		// Startwert: Integer.MAX_VALUE (also die größte Zahl, die als int darstellbar ist)
		int kuerzesteLaenge = Integer.MAX_VALUE;
		
		// Alle Zahlen in der Liste durchgehen
		for (int zahl: input) {
			// falls die aktuelle Zahl kürzer als die bisherige kürzeste Zahl ist,
			// kuerzesteLaenge auf Länge von zahl setzen.
			if (Integer.toString(zahl).length() < kuerzesteLaenge) {
				kuerzesteLaenge = Integer.toString(zahl).length();
			}
			
			// Alternativ: kuerzesteLaenge = Math.min(kuerzesteLaenge, Integer.toString(zahl).length());
			// Also "setze kuerzesteLaenge auf das kleinere aus kuerzesteLaenge und Länge von zahl
		}
		
		// Länge der kürzesten Zahl zurückgeben
		return kuerzesteLaenge;
	}
	
	private static int findLow3s(int[] input) {
		// findLow3 als Stream
		// (hier werden erst die Längen aller Werte ermittelt und dann erst der Kleinste gesucht.)
		return Arrays.stream(input).map(n -> Integer.toString(n).length()).min().getAsInt();
	}
	
	private static int findLow4(int[] input) {
		// Kombination aus findLow2 und findLow3,
		// Also die tatsächliche Länge vergleichen, aber vorher das Minus abschneiden
		
		// Variable zur Suche nach der kürzesten Zahl erzeugen
		// Startwert: Integer.MAX_VALUE (also die größte Zahl, die als int darstellbar ist)
		int kuerzesteLaenge = Integer.MAX_VALUE;
		
		// Alle Zahlen in der Liste durchgehen
		for (int zahl: input) {
			// falls die aktuelle Zahl kürzer als die bisherige kürzeste Zahl ist,
			// kuerzesteLaenge auf Länge von zahl setzen.
			if (Integer.toString(Math.abs(zahl)).length() < kuerzesteLaenge) {
				kuerzesteLaenge = Integer.toString(Math.abs(zahl)).length();
			}
			
			// Alternativ: kuerzesteLaenge = Math.min(kuerzesteLaenge, Integer.toString(Math.abs(zahl)).length());
			// Also "setze kuerzesteLaenge auf das kleinere aus kuerzesteLaenge und Länge von zahl
		}
		
		// Länge der kürzesten Zahl zurückgeben
		return kuerzesteLaenge;
	}
	
	private static int findLow4s(int[] input) {
		// findLow4 als Stream
		// (Vor dem Vergleich werden wieder die Umwandlungen gemacht)
		return Arrays.stream(input).map(Math::abs).map(n -> Integer.toString(n).length()).min().getAsInt();
	}
}

KingAmadeus

Fragesteller

09.12.2020, 17:12

Danke dir. Werde mal alles ausprobieren. Bisher hat nichts funktioniert.

KingAmadeus

Fragesteller

09.12.2020, 17:43

Hat endlich funktioniert. Vielen Dank nochmal :)

daCypher

10.12.2020, 08:20

@KingAmadeus

Bitteschön

regex9

Von gutefrage auf Grund seines Wissens auf einem Fachgebiet ausgezeichneter Nutzer

Computer, Java

08.12.2020, 23:15

Suche erst die kleinste Zahl im Array.

Pseudocode:

min = numbers[0]

for i = 1, i < len(numbers), ++i
  if min > numbers[i]
    min = numbers[i]

Und teile danach die ermittelte Zahl so lange durch 10, bis sie selbst kleiner als 0 ist. Die Anzahl an Teilungen musst du mitzählen.

Beispiel:

125 / 10 = 12
12 / 10 = 1
1 / 10 = 0

=> 3 Zahlen

Da die Division mit ganzen Zahlen erfolgt, wird auch die Nachkommastelle abgetrennt. Sie ist für diese Berechnung eh nicht wichtig.

regex9

08.12.2020, 23:22

PS.: Mein Pseudocode geht davon aus, dass das Array mindestens einen Eintrag hat. Sollte dem nicht so sein, müsstest du dir eine Fehlerbehandlung einfallen lassen.

Des Weiteren wird für Teil 2 noch nicht beachtet, dass im Array auch negative Zahlen vorhanden sein könnten. Daher sollte vom Minimum erst der Betrag berechnet werden. Processing bietet dafür die abs-Funktion.

MrAmazing2

08.12.2020, 23:59

Für den letzten Schritt kann man auch einfach den 10er-Logarithmus +1 nehmen.

MrAmazing2

Von gutefrage auf Grund seines Wissens auf einem Fachgebiet ausgezeichneter Nutzer

Computer, Java

08.12.2020, 22:45

int findLow(int[] zahlen) {
  int min = 9999999; //eine hohe Zahl
  for (int i=0; i < zahlen.length; i++) {
    if ( zahlen[i] < min) {
      min = zahlen[i];
    }
  }
  return min;
}

Woher ich das weiß:Hobby – Programmieren ist mein Hobby & Beruf

KingAmadeus

Fragesteller

08.12.2020, 22:51

Das gibt aber nicht die Anzahl der Ziffern zurück.

Das Ergebnis sollte so aussehen:

findLow([1,2,3,4]) --> liefert 1

findLow([126425,12345,123,12,112]) --> liefert 2

MrAmazing2

08.12.2020, 22:59

@KingAmadeus

True, das hab ich vergessen.

Tausch beide

zahlen[i]

mit

(int)(Math.log10(zahlen[i])+1)

aus.

KingAmadeus

Fragesteller

08.12.2020, 23:01

@MrAmazing2

Jo, geht nicht :)

KingAmadeus

Fragesteller

08.12.2020, 23:04

@KingAmadeus

Kann man das nicht irgendwie in eine String umwandeln? Ich wüsste dann nicht wie ich daraus die kleinste Zahl herausbekomme

orochi02

08.12.2020, 23:11

@KingAmadeus

String.valueOf https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html#valueOf(int)

MrAmazing2

08.12.2020, 23:57

@KingAmadeus

Tests nochmal, hab meine Antwort da noch editiert, das sollte eigtl schon gehen, so wie sie jetz is.

MrAmazing2

09.12.2020, 00:03

@KingAmadeus

Kannst du natürlich auch machen, is aber Performancetechnisch nich zu empfehlen.

Ähnliche Fragen

Java array rückwärts?

package uebung1;
import java.util.Random;
public class Felder {
public int[] fuellen(int o, int l) {
int zahlen[] = new int[l];
Random rnd = new Random();
for (int x = 0; x < zahlen.length; x++) {
zahlen[x] = rnd.nextInt(o + 1);
}
return zahlen;
}
public int[] fuellen(int u, int o, int l) {
int zahlen[] = new int[l];
Random rnd = new Random();
for (int x = 0; x < zahlen.length; x++) {
zahlen[x] = rnd.nextInt(o - u) + u;
}
return zahlen;
}
public void ausgeben(int zahlen[]) {
for (int x = 0; x < zahlen.length; x++) {
if (x == 0) {
System.out.print("[");
}
System.out.print(zahlen[x]);
if (x != zahlen.length - 1) {
System.out.print(", ");
}
if (x == zahlen.length - 1) {
System.out.println("]");
}
}
}
public void ausgebenrueckwaerts(int zahlen[]) {
for (int x = zahlen.length-1; x >= 0; x--) {
if (x == zahlen.length-1) {
System.out.print("[");
}
System.out.print(zahlen[x]);
if (x != 0) {
System.out.print(", ");
}
if (x == 0) {
System.out.println("]");
}
}
}
public void drei_fuenf(int zahlen[]) {
for (int x = 0; x < zahlen.length; x++) {
if (zahlen[x] % 3 == 0 && zahlen[x] % 5 == 0) {
System.out.println("Hello Zahl: " + zahlen[x]);
} else if (zahlen[x] % 3 == 0) {
System.out.println("Fizz Zahl: " + zahlen[x]);
} else if (zahlen[x] % 5 == 0) {
System.out.println("Buzz Zahl: " + zahlen[x]);
}
}
}
public boolean finde(int z, int zahlen[]) {
boolean found = false;
for (int x = 0; x < zahlen.length; x++) {
if (zahlen[x] == z) {
found = true;
break;
}
}
return found;
}
public int finde_pos(int z, int zahlen[]) {
int pos = -1;
for (int i = 0; z != zahlen[i]; i++) {
pos++;
}
pos++;
return pos;
}
public int finde_anz(int z, int zahlen[]) {
int anz = 0;
for (int i = 0; i < zahlen.length; i++) {
if (zahlen[i] == z) {
anz++;
}
}
return anz;
}
}

...zur Frage

Array Werte einfügen/löschen/ändern?

Hallo ich bin gerade am Java lernen und habe folgendes Problem:

Ich habe ein Array erstellt in dem ich angebe wie viele Zahlen ich eingeben will und diese dann eingeben kann. Nun möchte ich über Switch-Case dem Benutzer die Möglichkeit geben Werte neu an eine beliebige Stelle einzufügen / einen Wert zu löschen / oder einen Wert abzuändern.

import java.util.Scanner;


public class Hausaufgabe71 {


    public static void main(String[] args) {
        Scanner eingabe = new Scanner(System.in);
        
        System.out.println("Wie viele Zahlen sollen eingegeben werden?");
        int anzahlZahlen = eingabe.nextInt();
        double[] zahlen = new double[anzahlZahlen];
        for (int i = 0; i < zahlen.length; i++) {
            System.out.print("Zahl " + (i + 1) + ": ");
            zahlen[i] = eingabe.nextDouble();
        }
        System.out.print("\nAktuelle Zahlen: ");
        for (double element : zahlen) {
            System.out.print(element + " ");
        }
        
        System.out.println("\nSumme: " + summe(zahlen) + " " + "Durchschnitt: " 
                + durchschnitt(zahlen));
        
        System.out.println("Was möchten Sie tun?\n1) Zahl einfügen\n2) Zahl"
                + " löschen \n3) Zahl ändern \n4) Beenden");
        
        int menue = eingabe.nextInt();
    
        switch (menue) {
        case 1:
            System.out.println("\nAn welcher Position möchten Sie die Zahl "
                    + "ändern?\n(1 = erste Zahl; " + (zahlen.length + 1) 
                    + " = hinten anfügen)");
            int pos = eingabe.nextInt();
            
            break;
            


        }
        
    }
    public static double summe(double[] zahlen) {
        double sum = 0;
        for (double value : zahlen) {
            sum += value;
        }
        return sum;
    }
    public static double durchschnitt(double[] zahlen) {
        double dur = 0;
        for (int i = 0; i < zahlen.length; i++) {
            dur += zahlen[i];
        }
        return dur / zahlen.length;
    }
}

Das ist mein bisheriger Quelltext.

Hat jemand einen Ansatz für mich wie ich diese Punkte realisiere?

MfG

...zur Frage

Wie zufällige zahl von bei Processing erschaffen?

Als private int varriable einstellen?

...zur Frage

Modalwert in C programmieren?

Ich möchte den Modalwert aus einem Array herausfinden:

int modal(int mod[], size_t n, int *modalwert) {
  int hzahl = mod[0]; // Zahl die am häufigsten vorkommt
  int hanz = 0; // Anzahl die am höchsten ist
  int zahl[n]; // Zahlen die gesucht werden
  int anz[n]; // Anzahl wie oft eine Zahl vorkommt

  int i,j;    // Zählervariablen

  for (j = 0; j < (int)n; j++) {
    anz[j] = 0;

    if (!kamvor(zahl, n, mod[j])) {
      zahl[j] = mod[j];
    }
    else {
      continue;
    }

    for (i = 0; i < (int)n; i++) {
      if (zahl[j] == mod[i]) {
        anz[j]++;
      }
    }

    if (anz[j] > hanz) {
      hanz = anz[j];
      hzahl = zahl[j];
    }
  }

  // Überprüfen ob die größte Anzahl nur einmal vorkommt
  int vork = 0; // Zählt mit, wie oft die größte Anzahl vorkommt

  for (i = 0; i < (int)n; i++) {
    if (anz[i] == 0) {
      continue;
    }

    if (anz[i] == hanz) {
      vork++;

      if (vork == 2) {
        return 0;
      }
    }
  }

  *modalwert = hzahl;
  return 1;
}

int kamvor(int zahlen[], size_t n, int zahl) {
  int i;

  for (i=0; i < (int)n; i++) {
    if (zahlen[i] == zahl) {
      return 0;
    }
  }

  return 1;
}

Die Funktion gibt 0 zurück, wenn es keinen Modalwert gibt. 1, wenn schon.

Das Ganze funktioniert jedoch nicht. 😟

...zur Frage

Wie kann ein Zahl in ein Array von Ziffern überführt werden?

Hallo, Wie kann ein Zahl in ein Array von Ziffern überführt werden (in Java), OHNE die Zahl zu keinem Zeitpunkt in einen String umgewandelt werden. Danke im Voraus.

...zur Frage

Wie lasse ich bei Java die Anzahl der geraden Zahlen in einem beliebig großen Array ausgeben?

Ein Array und so Zeug hab ich schon und brauche nun eine Methode um die Anzahl der geraden Zahlen auszugeben. Mein Ansatz sieht bisher wie folgt aus:

int istgerade = 0; int i = 0; while (i <= array.length){ if (array[i]%2 == 0){ istgerade++; i++; } }

System.out.print(istgerade) ;

Die Idee dahinter ist, dass solange i (also die Position im Array) kleiner oder gleich der Länge des Arrays ist (hab es auch schon nur mir "kleiner als" versucht) wird überprüft ob die Zahl im Array an der Stelle i gerade ist (%2 == 0 muss ja gerade sein), wenn das nun der Fall ist soll der "istgerade Zähler" hochspringen...was mache ich falsch?

...zur Frage

Array nach Wert prüfen rekrusiv (java)?

Hi sagen wir mal ich habe einen COde der so aussieht:

  public static int calculateBinomialCoefficient (int n, int k)
   {
      if (k == 1)
         return n;
      else if (n >= k && k == 0)
         return 1;
      else
       return (n * calculateBinomialCoefficient(n - 1, k - 1) / k);
 
   }
}

Nun hat mein Prof gemeint, dass die rekursion nicht linear ist und zu vielen gleichen Aufrufen mit gleichen Parameterkombis führt. EIne Möglichkeit damit das besser läuft ist es berechente Binomialkoeffizienten in einem zwei dimensionalen Array zu speichern und vor einem rekursiven Aufruf zu prüfen, ob die Lösung bereits 1x exisitert hat. EInen Array haben wir schon gegeben, mit der perfekten Länge.Dann habe ich mir das überlegt:

 public static int calculateBinomialCoefficient (int n, int k)
  {
   if (k == 1)
     return n;
   else if (n >= k && k == 0)
     return 1;
   else
for (int a=0; a<array.length;a++)
{
for (int b=0; b<array.length;b++)
{
if (array[a][b]==(n * calculateBinomialCoefficient(n - 1, k - 1) / k)
{
return array[a][b];
}else{
return (n * calculateBinomialCoefficient(n - 1, k - 1) / k);
if(array[a][b]==0){
array[a][b]==(n * calculateBinomialCoefficient(n - 1, k - 1) / k);
}
}
}
}
     
 
  }
}

(Ich hoffe kann man erkennen Tabs sind bisschen verrückt.)

Aber warum funktioniert das nun nicht? Habe doch alles beachtet oder?

...zur Frage

C# random array?

Ich habe hier in dem Code ein Random-Array erstellt. Wenn ich es starte, bekomme ich immer ein Array mit gleichen Zahlen. Wenn ich einen Breakpoint reinmache und es durchlaufen lasse, liefert es mir ein Array mit unterschiedlichen Zahlen. Ich weiß nicht mehr weiter! Kann mir bitte wer helfen? Danke.

Hier der Code:

static void Main(string[] args)
{
  int[] arr = new int[6];
  RandomArray(arr);

  for (int i = 0; i < arr.Length; i++)
  {
    Console.WriteLine(arr[i]);
  }

  Console.ReadKey();
}

static int[] RandomArray(int[] arr)
{
  for (int i = 0; i < arr.Length; i++)
  {
    Random zufallszahlen = new Random();
    int zahl = zufallszahlen.Next(1, 45);
    arr[i] = zahl;
  }

  return arr;
}

...zur Frage

wie berechne ich das Produkt eines Arrays?

Ich habe echt alle jetzt hinbekommen aber jetzt fehlt mir das Produkt ich wollte das so machen

int produkt = 0;

produkt *= Array[i]; system.out... (produkt);

aber da kommt immer ein Fehler in der console undzwar :** Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2 at Array.main(Array.java:36) 0**

hier erstmal mein Code import java.util.Scanner;

public class Array {

public static void main(String[] args)
{
    // TODO Auto-generated method stub
    {
        Scanner input=new Scanner(System.in);
        int summe=0;
       

        System.out.print("Wie groß soll das Array sein?");
        int Arraygroeße=input.nextInt();

        int Array[]=new int[Arraygroeße]; // erstellt ein Array mit der
                                          // Größe
                                          // die man eingibt

        int i;
        for (i=0; i<Array.length; i++)
        {
            System.out.print("Feldwert an Stelle "+i+" eingeben: ");
            Array[i]=input.nextInt(); // soll den Wert einlesen den der
                                      // Nutzer
                                      // haben möchte bis das ganze Array
                                      // ausgefüllt ist
        }

        for (i=0; i<Array.length; i++)



            summe+=Array[i];
        System.out.println("Die Summe ist :"+summe);

        int max=Array[0];
        for (i=0; i<Array.length; i++)
            if (max<Array[i])
                max=Array[i];

        System.out.println("Größter Wert des Arrays ist "+max);

        int min=Array[0];
        for (i=0; i<Array.length; i++)
            if (min>Array[i])
                min=Array[i];

        System.out.println("Kleiner Wert des Array ist "+min);

        double mittel=0; // Mittelwert auf 0 setzen
        mittel=summe/Array.length; // Mittelwert berechnen durch Summe
                                   // geteielt durch die Anzahl der Zahlen
                                   // im Array
        System.out.println("Der Mittelwert beträgt:  "+mittel);
        
       
        input.close();

    }
  }
}

kann mir jemand bitte helfen wie ich das Produkt berechnen kann ? ( Java)

...zur Frage

Array jeden wert addieren?

package com.companyenelogy;

import java.lang.reflect.Array;
import java.util.Scanner;

public class Main {

    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);

        System.out.println("Geben sie ihr Array ein:");

        int[] array = new int[scanner.nextInt() ];

                System.out.print("Das Array beinhaltet folgende Zahlen: ");
        for (int i = 0; i < array.length; i++) {
            array[i] = i + 1;

        }
        for (int i = 0; i < array.length; i++) {
         
            System.out.print(array[i] + ",");
;
        }

        /*
        *Schreibe folgende Funktion: Jedem Wert im Array soll die 13 addiert werden (Verschlüsslung der Zahlen

ich kriege diese aufgäbe nicht hin ich muss jede Zahl in einen array mit 13 addieren aber wen ich was versuche wird nur die erste Zahl mit 13 addiert

...zur Frage

Java void-Methode: If return, oder If else. Was ist professioneller?

Ein If mit Return:

public void printArray(int[] array) {
  if(array.length > 0) {
    System.out.println("Content of Array:");
    System.out.println(Arrays.toString(array));
    return;
  }
  System.out.println("Array is empty");
}

Ein If mit Else:

public void printArray(int[] array) {
  if(array.length > 0) {
    System.out.println("Content of Array:");
    System.out.println(Arrays.toString(array));
  } else {
  System.out.println("Array is empty");
  }
}

Was ist professioneller?

...zur Frage

Anzahl aller gefüllten Arrays aufzählen in Java?

Wie lautet die Syntax zur Aufzählung der gefüllten Arrays in Java?

Beispiel:

int[ ] array = new int[4];

array[0] = 3;

Die restlichen bleiben leer und man möchte auf die Konsole, die Anzahl der gefüllten Arrays, anzeigen. (Nur die Anzahl nicht den Wert!)

...zur Frage

Wie eine Ziffer/Dezimalzahl im Array speichern?

Schreiben Sie nun eine Methode, die zu der übergebenen Zahl n die Ziffer zurück-gibt, die am häufigsten in der Dezimaldarstellung der Zahl n vorkommt. Sollten mehrere Ziffern gleichhäufig vorkommen, so soll die kleinste der Ziffern zurückgegeben werden. Beispiel: Für die Zahl n=2031771 kommen die Ziffer 1 und 7 jeweils zweimal vor. Es muss also in diesem Fall die 1 zurückgegeben werden.Sie dürfen die Methode public static int berechneHäufigstenWert(int[] feld) aus Aufgabenteil a) benutzen.

public static int berechneHaeufigsteZiffer(int n)

{

assert(n>0);

}

...zur Frage

Wie kann man bei Java ein Integer in einzelne ziffern runterbrechen und jede ziffer in einem eigenen Feld in einem array speichern?

Hallihallo,

ich soll ein programm schreiben, bei dem eine 8 stellige zahl eingelesen wid, die nur aus 4 ziffern besteht und jede ziffer entspricht einem zeichen anschließend soll mein programm die ziffern in die entsprechenden zeichen umwandeln und in die ausgabe schreiben. meine idee war ein array anzulegen, dass 8 felder besitzt und dann quasi für jedes feld zu prüfen welchem zeichen es entspricht ...

wie liest man also eine ganze zahl ein, bricht sie dann in ziffern herunter und speichert jede einzelne zahl in einem array feld?

...zur Frage

Was möchtest Du wissen?

Deine Frage stellen