[Java] charAt(i) == '.' => rare resultaten *

[Lima]

Als ik charAt(i) == '.' doe op een bepaalde string om te controleren of er een punt in zit werkt dit niet. Het lijkt alsof hij voor die punt gelijk welk getal in de plaats kan zetten.
Nu ken ik nog niet zo veel van java, maar een zoektocht leidde me tot deze url:
http://java.sun.com/j2se/...il/regex/Pattern.html#sum
daar kwam ik ergens tegen dat een . een Predefined character class is en daarbij staat:
Any character (may or may not match line terminators)
Maar uit mijn eigen programma kan ik afleiden dat als ik een letter ingeef voor de char, de voorwaarde == '.' niet voldaan is.

dit is het stuk code:

Java:

    public void bepaalCijferstelsel() {
        for (int i = 0 ; i < input.length() ; i++) {
            if (i == 0) {
                if (input.charAt(i) == '0' || 
                    input.charAt(i) == '1' ||
                    input.charAt(i) == '2' ||
                    input.charAt(i) == '3' ||
                    input.charAt(i) == '4' ||
                    input.charAt(i) == '5' ||
                    input.charAt(i) == '6' ||
                    input.charAt(i) == '7' ||
                    input.charAt(i) == '8' ||
                    input.charAt(i) == '9') {
                    stelsel = 1;
                }
                else if (input.charAt(i) == 'I' ||
                         input.charAt(i) == 'V' ||
                         input.charAt(i) == 'X' ||
                         input.charAt(i) == 'L' ||
                         input.charAt(i) == 'C' ||
                         input.charAt(i) == 'D' ||
                         input.charAt(i) == 'M' ||
                         input.charAt(i) == '.') {
                    stelsel = 2;
                }
                else {
                    stelsel = 0;
                }
            }
            else {
                if (stelsel == 1 &&
                    input.charAt(i) == '0' || 
                    input.charAt(i) == '1' ||
                    input.charAt(i) == '2' ||
                    input.charAt(i) == '3' ||
                    input.charAt(i) == '4' ||
                    input.charAt(i) == '5' ||
                    input.charAt(i) == '6' ||
                    input.charAt(i) == '7' ||
                    input.charAt(i) == '8' ||
                    input.charAt(i) == '9') {
                    stelsel = stelsel; // deze lijn is niet nodig
                }
                else if (stelsel == 2 &&
                         input.charAt(i) == 'I' ||
                         input.charAt(i) == 'V' ||
                         input.charAt(i) == 'X' ||
                         input.charAt(i) == 'L' ||
                         input.charAt(i) == 'C' ||
                         input.charAt(i) == 'D' ||
                         input.charAt(i) == 'M' ||
                         input.charAt(i) == '.') {
                    stelsel = stelsel; //deze lijn is niet nodig
                }
                else {
                    stelsel = 0;
                    break;
                }
            }
            //debug info
            System.out.println("stelsel = " + stelsel + "  &  i = " + i);
        }

het is dus de bedoeling om te detecteren welk talstelsel er van toepassing is. Ik gebruik geen parseint was als die false is moet je toch je string afgaan om te kijken of het dan een Romeins cijfer is. Verder kan ik hierdoor ook sneller kijken of het ingevoerde getal niet fout is. Als het teken na het eerste teken niet van hetzelde talstelsel is dan spring ik uit de lus en zet stelsel op 0 (= fout).
Ook vraag ik me af of die if condities niet korter kunnen...nu was ik eens beginnen zoeken op die url en kwam daar iets interessants tegen nl. /d maar dit hoe ik dat kan gebruiken snap ik niet goed. Maar als mijn probleem met de punt verduidelijkt is ben ik al een zeer tevreden tweaker.
En ja deze opdracht is voor school, maar normaal moeten we zo ver niet gaan als ik dat doe. Maar ik doe het liever 100% goed. Je moet maar tot aan een bepaald Romeins getal aankunnen, mar ik wil het maximum maar die punt strooit roet in het eten en ik geraak er echt niet wijs uit.

[Jaap-Jan]

Een punt is alleen een predefined character class binnen een regex.

Dit is geen regex, maar een simpele vergelijking of een teken een punt is:

Java:

 char ch = input.charAt(i);

 if (ch == '.') {
    //doe iets
}

En die reusachtige if constructies kunnen inderdaad korter. Zet alle tekens van een getallenstelsel in een char array en loop daar doorheen met een for-loop. Voor stelsel 1 kun je het zelfs nog simpeler maken:

Java:

if (ch >= '0' && ch <= '9') {
   //getal behorende tot stelsel 1
}

En als je het stelsel weet, kun je een manier bedenken om te kijken of de rest van de tekens ook kloppen:

1. Zoek aan de hand van het eerste teken uit tot welk stelsel het getal behoort.
2. Kijk of de rest van de tekens ook tot dat stelsel behoren. Zo nee: stelsel = 0

Voor het tweede punt kun je in het geval van stelsel 1 natuurlijk ook parseInt() gebruiken en als die een exception throwt stelsel op 0 zetten.

Wat is de input? En is de 'punt' die daar in voorkomt ook een UTF-8 teken met als waarde 46 of 0x2E?

Houdt je er ook rekening mee dat "IMDXVI" geen romeins getal is, al behoren alle letters tot dat stelsel? Je zult dus nog een extra semantische controle moeten doen.

[ Voor 7% gewijzigd door Jaap-Jan op 13-11-2008 15:55 ]

[Phyxion]

Je kan eens .equals of .compareTo ofzo proberen.

[Twazerty]

if (stelsel == 1 && input.charAt(i) == input.charAt(i).isChar(i)); is beter als wat jij doet.
Heb zo even geen java bij de hand en mijn kunsten zijn ook nog niet zo goed

Als je je
else if (stelsel == 2 &&
input.charAt(i) == 'I' ||
bekijk lijkt me dat er iets fout gaat.

[Lima]

Bedankt voor je reply!
We mogen nog geen arrays gebruiken op school dus dat valt al af...die andere methode voor 0 t.e.m. 9 is inderdaad wel bruikbaar.
Maar men heikelpunt blijft hetzelfde. Ik zal een voorbeeld geven om te verduidelijken.

Als input == "IV1" dan krijg ik stelsel = 2
Dit klopt dus niet, dit moet stelsel = 0 zijn. Als ik daarentegen IVa doe, dan krijg ik dus wel stelsel = 0. Dit snap ik dus helemaal niet... als je wilt zet ik ff volledige code erop (is slechts 122 lijnen) zodat je snel ff kan compileren en men probleem ook kan zien?

[pedorus]

Nog wat aanvullende vragen dan:
Waarom behoort een punt tot het romeinse tallenstelsel? Of doe je ook aan fracties (bijvoorbeeld, "∴"=3/12=1/4)? Mogen negatieve nummers niet? Is void het juiste return-type? Zou je iets met switch kunnen doen? Zou "IIIIII", "VX" of "VV" een correct romeins nummer mogen zijn (tricky)?
Waarom zet je stelsel iedere keer opnieuw, zonder goed te kijken naar de huidige waarde? (prioriteit && vs ||)

Het is in ieder geval een mooi staaltje WTF-code, waar je later nog eens leuk naar terug kan kijken. Zelf zou ik bijvoorbeeld wel gewoon parseInt gebruiken

De arrays letters en numbers van dit voorbeeld zijn misschien wel nuttig voor de conversie (validatie romeins cijfer klopt niks van daar).

[Big Womly]

Ik zou ook nog eens naar je haakjes kijken. && heeft een hogere prioriteit dan ||, dus nu staat er eigenljik

Java:

if ( (stelsel == 1 && input.charAt(i) == '0') ||  
     input.charAt(i) == '1' || 
     input.charAt(i) == '2' || 
     input.charAt(i) == '3' || 
     input.charAt(i) == '4' || 
     input.charAt(i) == '5' || 
     input.charAt(i) == '6' || 
     input.charAt(i) == '7' || 
     input.charAt(i) == '8' || 
     input.charAt(i) == '9') { 
          stelsel = stelsel; // deze lijn is niet nodig 
     } 

[Lima]

pedorus schreef op donderdag 13 november 2008 @ 16:02:
Nog wat aanvullende vragen dan:
Waarom behoort een punt tot het romeinse tallenstelsel? Of doe je ook aan fracties (bijvoorbeeld, "∴"=3/12=1/4)? Mogen negatieve nummers niet? Is void het juiste return-type? Zou je iets met switch kunnen doen? Zou "IIIIII", "VX" of "VV" een correct romeins nummer mogen zijn (tricky)?
Waarom zet je stelsel iedere keer opnieuw, zonder goed te kijken naar de huidige waarde? (prioriteit && vs ||)

Het is in ieder geval een mooi staaltje WTF-code, waar je later nog eens leuk naar terug kan kijken. Zelf zou ik bijvoorbeeld wel gewoon parseInt gebruiken

De arrays letters en numbers van dit voorbeeld zijn misschien wel nuttig voor de conversie (validatie romeins cijfer klopt niks van daar).

een punt behoort wel degelijk tot het romeinse tallenstelsel:
* I = 1
* V = 5
* X = 10
* L = 50
* C = 100
* D = 500
* M = 1000
* V.M = 5.000
* X.M = 10.000
* L.M = 50.000

negatieve nummer mogen niet, dus daarom daar geen check op bij het eerste karakter. Ik snap niet goed wat je bedoelt me men stelsel elke keer opnieuw instellen? Eenmala het eerste karakter het talstelsel bepaalt heeft, kijk ik elk karakter verder of dit wel goed blijft, bij verandering resulteert dit in een fout, bij geen veranderd blijft het huidige talstelsel behouden.
En parseInt zou ik enkel kunnen gebruiken voor het arabische stelsel, voor het romeinse moet ik toch per char nakijken.
Arreays heb ik al gezegd, die mag ik niet gebruiken. En checken of een romeins nummer dan wel correct is doe ik later in een andere functie. In deze functie wil ik juist het type talstelsel bepalen, daarna kijk ik wel of er bijv niet 0000123 of IIIIIIII is ingevuld.

edit: inderdaad men haakjes moet ik nakijken, dat heb ik precies over het hoofd gezien hierdoor is mijn probleem dus ook opgelost. Nu kan ik beginnen met de effectieve omzetting..dit wordt ook nog een uitdaging in die link staat wel wat info, maar ik wil het zelf eerst uitdenken

[ Voor 6% gewijzigd door Lima op 13-11-2008 16:19 ]

[pedorus]

L i m a schreef op donderdag 13 november 2008 @ 16:13:
een punt behoort wel degelijk tot het romeinse tallenstelsel:
* V.M = 5.000
* X.M = 10.000
* L.M = 50.000

Ha, dat is een wikipediawijsheid die ik toevallig alleen in de Nederlandse versie terugzie, zonder bron. En ook daar staat trouwens dat er een spatie moet volgen Volgens mij is "." de product-constructie, waardoor V.MI dan dus

code:

_
VV

wordt (5.005). Dit in tegenstelling tot V.M I dan weer, maar je staat geen spaties toe

Arreays heb ik al gezegd, die mag ik niet gebruiken.

Gebruik de laatste versie die je quote

[Lima]

hmm in verband met die punt kan het inderdaad nog interessant worden...maar dat valt buiten het onderwerp van dit topic denk ik. Men probleem is opgelost, men if's zijn korter geworden dus ik denk niet dat er nog veel te zeggen valt?
In ieder geval bedankt iedereen voor de snelle reacties!

[Bosmonster]

L i m a schreef op donderdag 13 november 2008 @ 16:01:

We mogen nog geen arrays gebruiken op school dus dat valt al af...

Ow, ik kreeg altijd complimenten als ik iets gebruikte dat we nog niet gehad hadden, maar dat is tegenwoordig misschien anders.

[pedorus]

Bosmonster schreef op donderdag 13 november 2008 @ 17:26:
Ow, ik kreeg altijd complimenten als ik iets gebruikte dat we nog niet gehad hadden, maar dat is tegenwoordig misschien anders.

Als je extra geavanceerde dingen gebruikt, dan leer je niet waar het om gaat natuurlijk. Bovendien is het lastigere nakijken...

Niet om in te leveren, hoewel dit wel een zeer korte oplossing is, maar even voor het archief:

Definitie en verificatie moderne romeinse cijfers 1 t/m 4.999 (MMMMCMXCIX) als regexp:

code:

^(M{0,4})(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$

Moderne romeinse cijfers 1 t/m t/m 4.999.999 in 'V.M-notatie' (MMMMCMXCV.M MMMMCMXCIX):

code:

^((M{0,4})(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(V)?\b\.M\b ?)?(M{0,4})(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})\b$

(je kan het testen met deze online regexp tester)

[Lima]

wow precies nog een hoop te leren. Want dit is echt totaal chinees voor mij...binnen 6 maand java zal ik er nog eens een blik op werpen

[pedorus]

L i m a schreef op donderdag 13 november 2008 @ 17:58:
wow precies nog een hoop te leren. Want dit is echt totaal chinees voor mij...binnen 6 maand java zal ik er nog eens een blik op werpen

Nou, ik verwacht niet dat ze je java regular expressions gaan leren hoor

[Jaap-Jan]

Ik heb zelf ook een oplossing gemaakt die simpele romeinse getallen (tot 3999) kan omzetten naar een integer, vergelijkbaar met Integer.parseInt(). De class is al met al 84 regels, inclusief nette foutmeldingen (exceptions).

Heeft me wel even wat gepuzzel gekost, maar het is doenbaar