NØTTER ("4 int", og flere!)

FraXinuS · 19. januar 2007

NØTT 1

Du har syv esker i ulike størrelser. Du har 40 baller og skal plassere et ulikt (oddetall) antall baller i hver eske (1,3,5,7 osv). Alle ballene skal i eskene. Noen løsninger?

7747985[/snapback]

Siden du sier at størrelsen på eskene er ulike, så tipper jeg kanskje dette er løsningen:

1: 1

2: 3

3: 5

4: 7

5: 9

6: 11

7: 4

nr 7 er den største esken og nr 6 den minste. Også sette man eske nr 6 oppi eske nr 7.

Da blir resultatet slik, uten at man har brukt mer en 40 baller.:

1: 1

2: 3

3: 5

4: 7

5: 9

6: 11

7: 15

misvisning · 19. januar 2007

FraXinuS: :thumbup:

Clue'et er å sette en eske inni en annen (for å unngå problematikken med at "et oddetall antall oddetall blir partall"). Da er det mange mulige løsninger.

misvisning · 17. februar 2007

Hva er det neste tallet i denne rekken?

1, 11, 21, 1211, 111221, ?

Magnus Holm · 18. februar 2007

Hva med 312211?

misvisning · 18. februar 2007

Riktig, og hva er tall nummer 100 i den rekken?

Magnus Holm · 18. februar 2007

Har ikke tid til nummer 100, men holder det med 58? Den er på rundt 6MB

http://www.mediamax.com/judofyr/Hosted/58.txt

misvisning · 19. februar 2007

Stakkars Håper virkelig du programmerte det og ikke talte selv.

Magnus Holm · 19. februar 2007

Så klart telte, jeg! Alt annet er jo for pyser :nei:

aadnk · 25. februar 2007

Jeg måtte bare prøve meg jeg òg, men, jeg gav opp på 75. Fullt utpakket tar filen 840 MiB:

http://home.lyse.net/aadnk/Filer/Math/75.7z

Endret 25. februar 2007 av aadnk

Jonas · 25. februar 2007

Jøss, hvordan klarer du å håndtere så store datamengder? Lagde selv litt kode for dette, men etter at filene runder 100kb er det sirup.

Poster koden her, kansje dere ser noe som kan optimaliseres!

Public Function CalculateNext(ByVal strNumber As String) As String

Dim blnDone As Boolean

Dim lngCount As Long

Dim lngCurrentPos As Long

Dim strCurrentChar As String

Do Until blnDone

DoEvents

lngCount = 1

lngCurrentPos = lngCurrentPos + 1

strCurrentChar = Mid(strNumber, lngCurrentPos, 1)

Do Until (Not strCurrentChar = Mid(strNumber, lngCurrentPos + 1, 1))

lngCurrentPos = lngCurrentPos + 1

lngCount = lngCount + 1

Loop

CalculateNext = CalculateNext & lngCount & strCurrentChar

If lngCurrentPos >= Len(strNumber) Then blnDone = True

Loop

End Function

CalculateNext("1") = "11"
CalculateNext("11") = "21"

CalculateNext("21") = "1211"

GeirGrusom · 25. februar 2007

- Do løkken kan byttes ut med en For løkke, eller en While løkke, da vil du slippe If setningen på slutten, men med en For løkke, slipper du lngCurrentPos

- Kutt ut DoEvents, den gjør ingen nytte, annet en å gjøre programmet tregere

- Dim strCurrentChar As String * 1, så blir det bare en byte

Offtopic: hvorfor i huleste granskauen bruker du hungarian notation?

Vel, "nytten" kan diskuteres et annet sted en her.

Jonas · 25. februar 2007

Hungarian notation? :blink:

Vet ikke.

Magnus Holm · 25. februar 2007

For ordentlig store datamengder må det vel C/C++ til...

GeirGrusom · 25. februar 2007

Tror ikke det spiller så stor rolle, teknikk er veldig viktig, som f.eks. å skrive til en midlertidig fil på disken, så vil bare

Hungarian Notation er at man skriver hva slags datatype variablene har, som et prefiks.

Jonas · 25. februar 2007

Prøvde å porte til C++ og det gikk *litt* fortere da. aadnk, hvordan løste du det?

Offtopic: hvorfor i huleste granskauen bruker du hungarian notation?
Vel, "nytten" kan diskuteres et annet sted en her.

8020435[/snapback]

Mener du det er galt?

GeirGrusom · 25. februar 2007

Jeg mener det er helt nytteløst, og fører til forvirring når en etterpå skal bruke koden.

Hungarian Notation

Min mening, men det er mye i bruk, blant annet i Unreal Script.

Magnus Holm · 25. februar 2007

Ser visst ut som at denne karen har funnet en matematisk løsning:

D(t+1) = (sigma(K=1,LOG(D(t)*10)-LOG(D(t)*10)%1,((D(t)-D(t)%10^(LOG(D(t))-
LOG(D(t))%1)+sigma(S=1,LOG(D(t))-LOG(D(t))%1,(((sigma(R=1,LOG(D(t)*10)

-LOG(D(t)*10)%1-1,ABS((D(t)*10-D(t)*10%10^(R+1))%10^(R+2)/10-(D(t)*10-D(t)*

10%10^R)%10^(R+1)))/10)-(sigma(R=1,LOG(D(t)*10)-LOG(D(t)*10)%1-1,ABS((D(t)*

10-D(t)*10%10^(R+1))%10^(R+2)/10-(D(t)*10-D(t)*10%10^R)%10^(R+1)))/10)

%10^(S-1))%10^S+1)%(((sigma(R=1,LOG(D(t)*10)-LOG(D(t)*10)%1-1,ABS((D(t)

*10-D(t)*10%10^(R+1))%10^(R+2)/10-(D(t)*10-D(t)*10%10^R)%10^(R+1)))/10)-(

sigma(R=1,LOG(D(t)*10)-LOG(D(t)*10)%1-1,ABS((D(t)*10-D(t)*10%10^(R+1))%10

^(R+2)/10-(D(t)*10-D(t)*10%10^R)%10^(R+1)))/10)%10^(S-1))%10^S+.5)*2*(D(t)

-D(t)%10^(S-1))%10^S))-(D(t)-D(t)%10^(LOG(D(t))-LOG(D(t))%1)+sigma(S=1,

LOG(D(t))-LOG(D(t))%1,(((sigma(R=1,LOG(D(t)*10)-LOG(D(t)*10)%1-1,ABS((D(t)

*10-D(t)*10%10^(R+1))%10^(R+2)/10-(D(t)*10-D(t)*10%10^R)%10^(R+1)))/10)

-(sigma(R=1,LOG(D(t)*10)-LOG(D(t)*10)%1-1,ABS((D(t)*10-D(t)*10%10^(R+1))%

10^(R+2)/10-(D(t)*10-D(t)*10%10^R)%10^(R+1)))/10)%10^(S-1))%10^S+1)%(((

sigma(R=1,LOG(D(t)*10)-LOG(D(t)*10)%1-1,ABS((D(t)*10-D(t)*10%10^(R+1))%

10^(R+2)/10-(D(t)*10-D(t)*10%10^R)%10^(R+1)))/10)-(sigma(R=1,LOG(D(t)*

10)-LOG(D(t)*10)%1-1,ABS((D(t)*10-D(t)*10%10^(R+1))%10^(R+2)/10-(D(t)*

10-D(t)*10%10^R)%10^(R+1)))/10)%10^(S-1))%10^S+.5)*2*(D(t)-D(t)%10^(S

-1))%10^S))%10^(K-1))%10^K/10^(K-1)*100^(2*sigma(N=1,K,(((D(t)-D(t)%

10^(LOG(D(t))-LOG(D(t))%1)+sigma(S=1,LOG(D(t))-LOG(D(t))%1,(((sigma(R=1,

LOG(D(t)*10)-LOG(D(t)*10)%1-1,ABS((D(t)*10-D(t)*10%10^(R+1))%10^(R+2)/10-

(D(t)*10-D(t)*10%10^R)%10^(R+1)))/10)-(sigma(R=1,LOG(D(t)*10)-LOG(D(t)*

10)%1-1,ABS((D(t)*10-D(t)*10%10^(R+1))%10^(R+2)/10-(D(t)*10-D(t)*10%10^R)%

10^(R+1)))/10)%10^(S-1))%10^S+1)%(((sigma(R=1,LOG(D(t)*10)-LOG(D(t)*10)%

1-1,ABS((D(t)*10-D(t)*10%10^(R+1))%10^(R+2)/10-(D(t)*10-D(t)*10%10^R)%

10^(R+1)))/10)-(sigma(R=1,LOG(D(t)*10)-LOG(D(t)*10)%1-1,ABS((D(t)*10-D(t)

*10%10^(R+1))%10^(R+2)/10-(D(t)*10-D(t)*10%10^R)%10^(R+1)))/10)%10^(S-1))

%10^S+.5)*2*(D(t)-D(t)%10^(S-1))%10^S))-(D(t)-D(t)%10^(LOG(D(t))-LOG(D(t))

%1)+sigma(S=1,LOG(D(t))-LOG(D(t))%1,(((sigma(R=1,LOG(D(t)*10)-LOG(D(t)*10)

%1-1,ABS((D(t)*10-D(t)*10%10^(R+1))%10^(R+2)/10-(D(t)*10-D(t)*10%10^R)%10^

(R+1)))/10)-(sigma(R=1,LOG(D(t)*10)-LOG(D(t)*10)%1-1,ABS((D(t)*10-D(t)*10%

10^(R+1))%10^(R+2)/10-(D(t)*10-D(t)*10%10^R)%10^(R+1)))/10)%10^(S-1))%10^

S+1)%(((sigma(R=1,LOG(D(t)*10)-LOG(D(t)*10)%1-1,ABS((D(t)*10-D(t)*10%10^

(R+1))%10^(R+2)/10-(D(t)*10-D(t)*10%10^R)%10^(R+1)))/10)-(sigma(R=1,

LOG(D(t)*10)-LOG(D(t)*10)%1-1,ABS((D(t)*10-D(t)*10%10^(R+1))%10^(R+2)/

10-(D(t)*10-D(t)*10%10^R)%10^(R+1)))/10)%10^(S-1))%10^S+.5)*2*(D(t)-D(t)%

10^(S-1))%10^S))%10^(N-1))%10^N+1)%(((D(t)-D(t)%10^(LOG(D(t))-LOG(D(t))%

1)+sigma(S=1,LOG(D(t))-LOG(D(t))%1,(((sigma(R=1,LOG(D(t)*10)-LOG(D(t)*

10)%1-1,ABS((D(t)*10-D(t)*10%10^(R+1))%10^(R+2)/10-(D(t)*10-D(t)*10%10^

R)%10^(R+1)))/10)-(sigma(R=1,LOG(D(t)*10)-LOG(D(t)*10)%1-1,ABS((D(t)*10-

D(t)*10%10^(R+1))%10^(R+2)/10-(D(t)*10-D(t)*10%10^R)%10^(R+1)))/10)%10^

(S-1))%10^S+1)%(((sigma(R=1,LOG(D(t)*10)-LOG(D(t)*10)%1-1,ABS((D(t)*10-

D(t)*10%10^(R+1))%10^(R+2)/10-(D(t)*10-D(t)*10%10^R)%10^(R+1)))/10)-

(sigma(R=1,LOG(D(t)*10)-LOG(D(t)*10)%1-1,ABS((D(t)*10-D(t)*10%10^(R+1))%

10^(R+2)/10-(D(t)*10-D(t)*10%10^R)%10^(R+1)))/10)%10^(S-1))%10^S+.5)*2*

(D(t)-D(t)%10^(S-1))%10^S))-(D(t)-D(t)%10^(LOG(D(t))-LOG(D(t))%1)+

sigma(S=1,LOG(D(t))-LOG(D(t))%1,(((sigma(R=1,LOG(D(t)*10)-LOG(D(t)*10

)%1-1,ABS((D(t)*10-D(t)*10%10^(R+1))%10^(R+2)/10-(D(t)*10-D(t)*10%10^

R)%10^(R+1)))/10)-(sigma(R=1,LOG(D(t)*10)-LOG(D(t)*10)%1-1,ABS((D(t)*

10-D(t)*10%10^(R+1))%10^(R+2)/10-(D(t)*10-D(t)*10%10^R)%10^(R+1)))/

10)%10^(S-1))%10^S+1)%(((sigma(R=1,LOG(D(t)*10)-LOG(D(t)*10)%1-1,

ABS((D(t)*10-D(t)*10%10^(R+1))%10^(R+2)/10-(D(t)*10-D(t)*10%10^R)%

10^(R+1)))/10)-(sigma(R=1,LOG(D(t)*10)-LOG(D(t)*10)%1-1,ABS((D(t)*

10-D(t)*10%10^(R+1))%10^(R+2)/10-(D(t)*10-D(t)*10%10^R)%10^(R+1)))

/10)%10^(S-1))%10^S+.5)*2*(D(t)-D(t)%10^(S-1))%10^S))%10^(N-1))%10^

N+.5))))/100)+(sigma(K=1,LOG(D(t)*10)-LOG(D(t)*10)%1,100^(1+sigma(N=

1,K-1,2*((((sigma(R=1,LOG(D(t)*10)-LOG(D(t)*10)%1-1,ABS((D(t)*10-D(t)*

10%10^(R+1))%10^(R+2)/10-(D(t)*10-D(t)*10%10^R)%10^(R+1)))/10)-(

sigma(R=1,LOG(D(t)*10)-LOG(D(t)*10)%1-1,ABS((D(t)*10-D(t)*10%10^(R+1))%

10^(R+2)/10-(D(t)*10-D(t)*10%10^R)%10^(R+1)))/10)%10^(N-1))%10^N/10^(N-

1)+1)%(((sigma(R=1,LOG(D(t)*10)-LOG(D(t)*10)%1-1,ABS((D(t)*10-D(t)*10%

10^(R+1))%10^(R+2)/10-(D(t)*10-D(t)*10%10^R)%10^(R+1)))/10)-(sigma(R=

1,LOG(D(t)*10)-LOG(D(t)*10)%1-1,ABS((D(t)*10-D(t)*10%10^(R+1))%10^(R+

2)/10-(D(t)*10-D(t)*10%10^R)%10^(R+1)))/10)%10^(N-1))%10^N/10^(N-1)+

.5)))))/10)

GeirGrusom · 25. februar 2007

sykt.... skulle ønske jeg hadde så mye fritid

aadnk · 25. februar 2007

Det er ikke noe problem å håndtere store datamengder dersom man benytter Streams. Da unngår man å måtte oppbevare hele datamengden i minnet. Koden jeg benyttet ser slik ut:

Imports System.IO

Public Class MorrisSequence

Public Event ProgressChanged(ByVal Sender As MorrisSequence, ByVal Value As Integer)

' Inn- og utdata

Public Input As TextReader

Public Output As TextWriter

' Hvorvidt prosessen er påskrudd

Public Running As Boolean

' Steg mellom hver gang "ProgressChanged" kalles

Public NotifyInterval As Integer = 100

Public Sub New()

' Tom initialisering.

End Sub

Public Sub New(ByVal Input As TextReader, ByVal Output As TextWriter)

' Initialiserer verdier

With Me

.Input = Input

.Output = Output

End With

End Sub

Public Sub Close()

' Lukk begge klasser

Input.Close()

Output.Close()

End Sub

Public Sub Execute()

Dim iChar As Integer, iPrev As Integer, iCount As Integer = 1, iStep As Integer

' Skru på prosessen automatisk

Running = True

' Hent standardverdi

iPrev = Input.Read

' Avslutt dersom inndataen er ugyldig

If iPrev < 0 Then

Exit Sub

End If

' Gå gjennom alle karakterer

Do While Running

' Teller antall steg

iStep += 1

' Ser om vi må informere om progresjonen

If (iStep Mod NotifyInterval) = 0 Then

RaiseEvent ProgressChanged(Me, iStep)

End If

' Hent den neste karakteren

iChar = Input.Read

' Avslutt om vi er ferdige

If iChar < 0 Then

' Skriv siste sekvens til utdatastrømmen

Output.Write(iCount & ChrW(iPrev))

Exit Do

End If

' Se om den tidligere karakteren differerer

If iPrev <> iChar Then

' Legg til i utdatastrøm

Output.Write(iCount & ChrW(iPrev))

' Tilbakestill variabler

iCount = 1

iPrev = iChar

Else

' Øk teller

iCount += 1

End If

Loop

' Vi er ferdige

Running = False

End Sub

End Class

For enkeltheten skyld har jeg vedlagt hele prosjektet i denne posten.

MorrisSequence.zip

FraXinuS · 11. juni 2007

Har aldri skjønt det med bitwise operations eller hva det heter. Men leste litt om det nå, fordi jeg trengte det til noe jeg holdt på å lage, og fant ut at det var veldig enkelt når jeg først skjønnte hva det gikk ut på.

Også kom jeg på nøtta i først post i denne tråden, og lagde denne:

def lik(a, b, c, d):
   return not (a | b | c | d) ^ (a & b & c & d)

den er veldig lik jorn79 sin, men bruke ingen sammenligninger. :cool:

NØTTER ("4 int", og flere!)

Anbefalte innlegg

Lenke til kommentar

Videoannonse

Lenke til kommentar

Lenke til kommentar

Lenke til kommentar

Lenke til kommentar

Lenke til kommentar

Lenke til kommentar

Lenke til kommentar

Lenke til kommentar

Lenke til kommentar

Lenke til kommentar

Lenke til kommentar

Lenke til kommentar

Lenke til kommentar

Lenke til kommentar

Lenke til kommentar

Lenke til kommentar

Lenke til kommentar

Lenke til kommentar

Lenke til kommentar

Opprett en konto eller logg inn for å kommentere

Opprett konto

Logg inn

Populær nå

Hvem er aktive 0 medlemmer