Matlab: enen tellen

[Merien]

The case:

Code: Selecteer alles

b(1,: )=[0 0 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 1 1 1 1 1]

Tel de enen in de verschillende groepen en laat ze weergeven in vector b(2, of waar je wilt.

Het resultaat zou zoiets moeten zijn:

Code: Selecteer alles

b(2,: )=[0 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0 0 0 0 0 0 5]

De volgorde of het aantal nullen doet er niet zoveel toe aangezien ik de uitkomsten (11 en 5 in dit geval) uiteindelijk wil middelen.

Van alles geprobeerd, maar mijn ideeen zijn op

[physicalattraction]

Ik heb het gevoel dat het volgende voorbeeld niet het meest elegante voorbeeld is, maar wel moet werken.

Code: Selecteer alles

X = 0;

Y = b(1, :D ;

countones = 0;

countgroups = 1;

for i = 1:length(Y)

   if Y(i) = 1;

      countones = countones + 1;

   else

      if countones>0

         X(countgroups) = countones;

         countones = 0;

      end

   end

end

if Y(end) = 1

   X(contgroups) = countones;

end

De laatste if statement is om ervoor te zorgen dat je de laatste groep ook meetelt. Die smiley is dus een dubbele punt met een haakje sluiten er achter.

[dirkwb]

Stel dat jouw vector b heet. Gebruik: sum( (b>0)) (let op de haken)

[Bart]

Als ik het goed begrijp wil je het aantal opeenvolgende 1-en weten (en dus niet het totaal aantal 1-en in een rij zoals dirk doet).

Ik ga er even van uit dat er alleen 1-en en 0-en in de rij zitten.

Code: Selecteer alles

function uitVector = eenentellen(inVector)

% inVector is de vector met de eenen. In jouw geval b(1,:)

% uitVector is de vector met de uitwaarden. In jouw geval b(2, :)

% We moeten eerst het begin en eindpunt van een opeenvolgende serie 1-en te vinden.

% Dit kun je het beste doen met een soort afgeleide door te kijken naar het verschil tussen x(i) en x(i+1):

verschil = inVector(2:end) - inVector(1:end-1);

% vind nu de begin indices van de 1-en

beginIndices = find(verschil > 0) + 1;

% Als het eerste getal in de serie een 1 is, dan moet die ook nog mee worden genomen in de beginIndices

if inVector(1) > 0

beginIndices = [1 beginIndices];

end

% Zelfde verhaal voor de eindindices

eindIndices = find(verschil < 0);

if inVector(end) > 0

eindIndices(end+1) = length(inVector);

end

% Nu is het een kwestie het verschil tussen de begin indices en eind

% indices te tellen en deze in een nieuwe vector te plaatsen

% vector alloceren

uitVector = zeros(size(inVector));

uitVector(eindIndices) = eindIndices - beginIndices + 1;

end

Nu is het een kwestie van intikken

Code: Selecteer alles

b(2, :) = eenentellen(b(1, :));

[Merien]

Stel dat jouw vector b heet. Gebruik: sum( (b>0)) (let op de haken)

Dan krijg ik niet het antwoord dat ik wil weten hoor. Lees mijn vraag even goed.

Ik wil uiteindelijk de gemiddelde grootte weten van de clusters enen. Op jouw manier tel je gewoon de enen op

[Bart]

Dan krijg ik niet het antwoord dat ik wil weten hoor. Lees mijn vraag even goed.

Ik wil uiteindelijk de gemiddelde grootte weten van de clusters enen. Op jouw manier tel je gewoon de enen op

Heb jij mijn vorig bericht gezien?

[Merien]

Heb jij mijn vorig bericht gezien?

Ja. Nadat ik mijn reactie had gepost.

[dirkwb]

Dan krijg ik niet het antwoord dat ik wil weten hoor. Lees mijn vraag even goed.

Ik wil uiteindelijk de gemiddelde grootte weten van de clusters enen. Op jouw manier tel je gewoon de enen op

Inderdaad ik las slecht , maar ja ik zag dat ik bart verderhielp (althans dat denk ik )

[oktagon]

In 1980,toen ik me begon te verdiepen in computertaal en dus ook binaire getallen en meen ik me te herinneren,dat elke stap naar links een gewichtsfactor 2 is met toename van de exponent van 0 naar het aantal nullen en enen.

Dus bijv het binaire getal 1001001 stelt in werkelijkheid 2⁶+ 0+0+2³+0+0+2⁰=...

Is -in deze topic-dit dus geen binair getal,waarbij dus het grootste getal van de enen overeenkomt met 2²³ en alle eropvolgende enen-behoudens tussenliggende nullen- een exp.lager en dat zootje bij elkaar optellen.

Maar door mutaties in de CT zullen er mogelijk veranderingen zijn opgetreden;na 1980 kreeg in het eerste orgel met lange wachttijden onder mijn tikgrage vingers!

[EvilBro]

Voor de lol:

Code: Selecteer alles

b = [1 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 1 1 1 1 1 0 0 0 1 1 1 1 0 0 0 1];



for i = 2:1:size(b,2),

  if b(1,i) == 1,

	b(1,i) = b(1,i-1) + 1; 

	b(1,i-1) = 0;

  end

end



sum(b)/sum(b>0)

[physicalattraction]

EvilBro, je code kan nooit werken, daar je op die manier nooit b(1,1) checkt en je dus hiermee een fout kan maken.

[EvilBro]

EvilBro, je code kan nooit werken, daar je op die manier nooit b(1,1) checkt en je dus hiermee een fout kan maken.

Kun je een voorbeeld geven van een \(b\) die niet tot een juist antwoord leidt?

[Merien]

Ik heb het gevoel dat het volgende voorbeeld niet het meest elegante voorbeeld is, maar wel moet werken.

Code: Selecteer alles

X = 0;

Y = b(1, :P ;

countones = 0;

countgroups = 1;

for i = 1:length(Y)

   if Y(i) = 1;

      countones = countones + 1;

   else

      if countones>0

         X(countgroups) = countones;

         countones = 0;

      end

   end

end

if Y(end) = 1

   X(contgroups) = countones;

end

De laatste if statement is om ervoor te zorgen dat je de laatste groep ook meetelt. Die smiley is dus een dubbele punt met een haakje sluiten er achter.

Superbedankt!

Je was alleen wel vergeten de countgroups te laten doortellen. Als je hem op deze manier draait telt ie alleen de laatste groep elke keer, maar dat probleempje was vlug opgelost.

Sorry Bart, ik heb jouw idee uiteindelijk niet gebruikt omdat het me wat omslachtiger leek , maar toch ook bedankt voor het meedenken

Ik ga het nu ff implementeren voor een vector met een miljoen elementen, want dat was het uiteindelijke doel.

[physicalattraction]

@EvilBro: Je hebt gelijk, ik zag even over het hoofd dat je b(i) = b(i-1)+1 gedaan hebt, en dat daar dus inderdaad b(1) gecheckt wordt.

@Merien: Oeps, inderdaad nog een countgroups = countgroups + 1 erin zetten. Ook zie ik dat ik een typfout gemaakt had. Maar dat zijn allemaal fouten die je met een keer testen makkelijk er uit haalt.

[EvilBro]

Nog even uitleggen wat mijn methode doet: er worden steeds twee opvolgende elementen bekeken. Op het moment dat het tweede element een 1 is, wordt de volgende substitutie toegepast:

Code: Selecteer alles

[ ... x 1 ...] -> [ ... 0 (x+1) ...]

Een keer de hele vector doorlopen en je hebt alle aaneengesloten 1-tjes opgeteld. Dan is het slechts nog een kwestie van even de totale som te delen door het aantal elementen dat ongelijk is aan nul.