Nur jeden vierten Index picken
Hallo,
mag sein das meine Frage etwas dumm ist aber ich komm gerade nicht drauf. Wie kann ich in einem Array nur jedes Vierte oder von mir aus auch jedes Xte object picken mithilfe einer For-Schleife ??
Beim Step gibst du anstelle von i++ was anderes an (z.B. i += 4).
Hallo,
ich weiß jetzt nicht ob ich dein Problem zu trivial finde aber mit etwas wie :
for (int i = 0; i<x; i +=4)
{
array[i];
}
wird jedes 4te element gewählt.
Gruß Daniel
Danke.
Man ich hatte voll das Blackout, bin heute sowieso ziemlich Müde. Danke nochmal. 🙂
Hallo Kaji,
nope, der 2. Durchlauf springt um 5 und erst danach 4 😁
Ich bin verantwortlich für das, was ich sage, nicht für das, was du verstehst.
**:::
Hallo,
wie kommst du darauf ?0+4=4 und 4+4=8? Es kommt nur drauf an ob man beim 0ten Eintrag anfängt oder nicht. Wenn du Eintrag 0 mit einrechnest dann geht es genau auf, wovon ich ausgegangen war 🙂
Hallo zusammen,
in diesem Zusammenhang ist auch der Modulo Operator oft hilfreich.
Hallo,
wie kommst du darauf ?0+4=4 und 4+4=8? Es kommt nur drauf an ob man beim 0ten Eintrag anfängt oder nicht. Wenn du Eintrag 0 mit einrechnest dann geht es genau auf, wovon ich ausgegangen war 🙂
OOps ... ich glaube, ich langsam aufhören ... sorry 😁
Ich bin verantwortlich für das, was ich sage, nicht für das, was du verstehst.
**:::
Hallo zusammen,
wenn man solche Schleifen baut, um dann im Rumpf auf a_, a[i+1], a[i+2] und a[i+3] zuzugreifen, dann musst bei der Schleifenbedingung aufpassen. i < a.Length wäre dann fatal, wenn nicht sichergestellt ist , dass die Anzahl der Element durch 4 teilbar ist.
herbivore
C# 3.0? Da ließe sich doch sicher 'ne Extension bauen oder?
sowas wie
public static IEnumerable<T> Every<T>(this IEnumerable<T> FromEnum, int x)
{
List<T> tList = FromEnum.ToList<T>();
var tQuery = from T pElement in tList
where (tList.IndexOf(pElement) % x) == 0
select pElement;
return tQuery;
}
Die Methoed müsste eigentlich jedes Element liefern, deren Index sich durch x teilen lässt - also jedes x-te Element.
Bitte mal um Verifizierung, ob die genannte Methode tut, was sie soll. Kann das gerade nicht testen. Danke!
Hallo Alle 🙂,
ich will jetzt nicht klugscheissen 😁 aber winSharp93 hat doch schon die (meiner Meinung nach) eleganteste Lösung verraten.
in diesem Zusammenhang ist auch der Modulo Operator oft hilfreich.
for(int i = 0; i < Array.Length;i++)
{
if(i % 4 == 0)
{
//muh
}
}
Schneller, simpler und leserlicher gehts doch nicht, oder?
Kalleberlin
Aber warum das Rad neu erfinden, wenn C# schon die nötigen Werkzeuge für soetwas bietet?
Naja, man kann ja mal 'nen Performance-Test fahren.
Ist meine Variante Thread-Safe? Ich bin mir gerade nicht sicher. Eure jedenfalls nicht.
Hallo 7.e.Q,
vebesser mich wenn ich falsch liege, aber
a: Was ist daran nicht C# Werkzeug?
b: Was ist daran nicht Threadsafe?
Kalleberlin
Hmmm, auf den ersten Blick...
a: klar, zufuß kommt man auch voran?
b: was, wenn während eines Schleifendurchlaufs in einem anderen Thread das Array oder ein Eintrag geändert, verschoben, getauscht, etc. wird?
Okay, mag sein, daß die Lösung einfach zu banal ist, um nicht thread-safe zu sein. Ist schon vergleichsweise spät. Ist mir gerade zu hoch, darüber intensiver nachzudenken.
b: was, wenn während eines Schleifendurchlaufs in einem anderen Thread das Array oder ein Eintrag geändert, verschoben, getauscht, etc. wird?
Ok, ich denke da hast Du recht. Ich weiss es zwar nur ganz genau wenn wir von einer List<T> sprechen würden (da würde es auf jedenfall knallen), deshalb denke ich Du hast da recht 😄.
Kalleberlin
@7.e.Q.
naja, deine Variante ist deutlich weniger performant. Überhaupt ist jeder Zugriff über IEnumerable (<T>) auf eine Liste oder ein Array, bei dem man direkt auf den Index des Elements zugreifen muss, auf jedenfall performancemäßig deutlich schlechter als manuell durch die Liste zu iterieren. Insofern ist hier das neu erfundene Rad deutlich schneller als zumindest Linq.
Und wegen threadsafe seh ich bei der Variante von Kalleberlin noch keinen Grund, warum die nicht mehr threadsafe sein kann, es gibt ja nur einen Zugriff auf eine lokal definierte Variable, auf die haben andere Threads keinen Zugriff. Der Code muss am Ende nicht threadsafe sein, aber wenn er es nicht ist, dann nicht wegen diesem Stück Code.
Also ich würde die Variante von Kalleberlin nehmen...
//edit: ja, stimmt, das Array müsste man noch absichern, dann ist's threadsafe. ist halt die Frage wo das Arrayherkommt...
Hallo Kalleberlin,
Schneller, simpler und leserlicher gehts doch nicht, oder?
die i += 4 Variante ist auf jeden Fall schneller und simpler finde ich sie auch.
herbivore
Hallo herbivore 🙂,
du selbst sagst doch aber :
wenn man solche Schleifen baut, um dann im Rumpf auf a_, a[i+1], a[i+2] und a[i+3] zuzugreifen, dann musst bei der Schleifenbedingung aufpassen. i < a.Length wäre dann fatal, wenn nicht sichergestellt ist , dass die Anzahl der Element durch 4 teilbar ist.
Was wiederum eine weitere Prüfung nach sich ziehen würde...
Das vermeidet man mittels des % Operators.
Kalleberlin
//Edit:
Und ob warum soll i+=4 schneller als i % 4 == 0 sein?
Hallo Kalleberlin,
Das vermeidet man mittels des % Operators.
nö, tut man nicht. Bei for (int i = 0; i < Array.Length; i++) if (i % 4 == 0) werden im innersten Block genau die gleichen Indexwerte berücksichtigt wie bei for (int i = 0; i < Array.Length; i += 4), nur dass die Schleife selbst bei der i % 4 == 0 Variante unnötigerweise viermal so oft durchlaufen wird und die im Vergleich zu den anderen Operationen teuere Modulo-Operation benutzt. Stelle dir vor, man will nur jeden tausendsten Index.
herbivore
Ach ich Idiot 😄!!!
An i += 4 innerhalb der for-Schleife hab ich depp gerade natürlich nicht gedacht!!
Bestes Zeichen zum schlafen gehen 😁
Gute Nacht 🙂
Wenn man seine App auf Geschwindigkeit auslegen möchte, ist es wichtig, dass man Operationen wie beispielsweise Modulo so gut es geht vermeidet und stattdessen auf (einfache) Addition und Multiplikation seine Algorithmen aufbaut.
In Zeiten von .NET und derzeit guten leistungsfähigen Rechner, wird man zwar das nur in Echtzeitsystemen berücksichtigen müssen, aber wie Herbivore schreibt bei einem Step von 1000 muss es absolut nicht sein.
Ist zwar nur eine Kleinigkeit, die man einspart, man muss aber dennoch nicht sinnlos Ressourcen verbraten.
Und in dem Sinne:
Mühsam ernährt sich das Eichhörnchen....
Es gibt 3 Arten von Menschen, die die bis 3 zählen können und die, die es nicht können...
Modulo dauert nicht länger als ein Div, da lediglich ein anderes Prozessorregister
den Rückgabewert beinhaltet.
Hallo FZelle,
schon klar, aber es dauert halt länger als Additionen.
Und dann kommt ja noch dazu, dass die Schleife selbst öfter durchlaufen wird, also statt einem Add und einem Vergleich hat man vier Adds, vier Modulos und acht Vergleiche, was insgesamt vermutlich 10 mal so teuer wäre.
herbivore
die i += 4 Variante ist auf jeden Fall schneller und simpler finde ich sie auch.
Das ist auch meine Meinung.
Daher habe ich meinen Beitrag auch eher als Ergänzung formuliert:
in diesem Zusammenhang ist auch der Modulo Operator oft hilfreich.
Wenn man nämlich sowieso alle Elemente durchgehen muss und jedem n. Element eine spezielle Behandlung zukommen lassen will, wäre das z.B. wirklich ein Fall für den Modulo Operator.