Hei
Pitäisi koodata c:llä ohjelma joka laskee kuukausien väliset päivät saman vuoden ajalta (eli haluttujen kuukausien väliset, mukaanlukien ko kuukaudet). Mitä rakennetta ja kaavaa tuossa kannattaisi käyttää? Switchillä olen kokeillut, mutta en saa toimimaan. Niin ja olen aloittelija näissä hommissa.
Kuulostaa koulu- tai kurssitehtävältä. Olethan käynyt läpi tehtäviin liittyvän materiaalin?
Laita vaan koodia näkyville niin voidaan ohjeistaa ja vältetään samalla vastausten koodaaminen valmiiksi. Entä onko laskuissa huomioitava karkausvuodet?
Otsikossa mainittiin C#
var alku = new DateTime(2019, 4, 3); var loppu = new DateTime(2019, 8, 10); Console.WriteLine((loppu - alku).TotalDays);
"Kuukausien välisien päivien laskeminen" ei kyllä kerro todellisesta tehtävänannosta mitään. Jokaisessa kuukaudessa on 30 tai 31 päivää, tietyin poikkeuksin, eli ei siinä ole mitään konkreettista laskemista. (Kuukausien välissä ei myöskään ole päiviä vaan jokainen päivä kuuluu johonkin kuukauteen.)
Koska kuukausien määrä on kohtalaisen pieni, 12 kpl, niin voit tosiaan halutessasi vaikka syöttää kaikki switchin sisälle ja käsitellä ne manuaalisesti, kunhan muistat huomioida karkauspäivän vaikutuksen.
Ensin sinun pitäisi kuitenkin ymmärtää, mitä oli tarkoitus tehdä. Koska et osaa kirjoittaa tehtävänantoa meille oikein, niin silloin minun on oletettava, ettet itsekään tiedä, mitä pitää tehdä. Et voi ratkaista ongelmaa ellet ymmärrä sitä.
Olisi myös oman oppimisesi kannalta hyödyllistä laittaa tänne vähintään yksi kokeilemasi ratkaisutapa, sillä silloin saat palautetta siitä, miksi se ei toimi. Silloin myös me näemme, että olet oikeasti viitsinyt käyttää edes sen kaksi minuuttia, mitä selvästi rikkinäisen ja ei-viitseliään yritelmän tekeminen vie...
Joka tapauksessa oman ns. tyhmän ja rikkinäisen koodin vertaaminen vierekkäin toimivan ratkaisun kanssa auttaa ymmärtämään koodaamisen prinsiippejä.
No niin, yritetäänpä uudestaan. Ja pahoittelut epäselvyydestä. Eli tehtävänanto:
"Kirjoita c-kielinen ohjelma, jossa main-funktiossa luetaan vuosiluku ja kaksi kuukauden numeroa. Ohjelma tulostaa kyseisen vuoden kuukausien välisten päivien lukumäärän ko. kuukausien päivät mukaanluettuna. Ohjelmassa on otettava huomioon mahdollinen karkausvuosi".
Tässä alla koodia mitä olen tuntikausia värkännyt. Laskee päin honkia, tiedän. Menossa on ns. "pakollinen" ohjelmointikurssi, joka kuuluu opiskelujeni oheen.
#include <stdio.h>
int karkausvuosi(int);
int main(void)
{
int vuosiluku;
int kuukausi;
int kuukausi2;
int lukumaara;
int tulos;
printf("Anna vuosi> ");
scanf("%d", &vuosiluku);
tulos = karkausvuosi(vuosiluku);
printf("Anna kuukausi nro 1.> ");
scanf("%d", &kuukausi);
printf("Anna kuukausi nro 2.> ");
scanf("%d", &kuukausi2);
if
(kuukausi < kuukausi2){
printf("Anna myohempi kuukausi ensin! ");
return (0);
}
switch(kuukausi)
{
case 1:
kuukausi = 31;
break;
case 2:
kuukausi = 59+28;
if (tulos == 1){
kuukausi = 59+27;
}
break;
case 3:
kuukausi = 90+31;
break;
case 4:
kuukausi = 120+30;
break;
case 5:
kuukausi = 151+31;
break;
case 6:
kuukausi = 181+30;
break;
case 7:
kuukausi = 212+31;
break;
case 8:
kuukausi = 243+31;
break;
case 9:
kuukausi = 273+30;
break;
case 10:
kuukausi = 304+31;
break;
case 11:
kuukausi = 334+30;
break;
case 12:
kuukausi = 365+31;
break;
}
switch(kuukausi2)
{
case 1:
kuukausi2 = 31;
break;
case 2:
kuukausi2 = 59;
if (tulos == 1){
kuukausi2 = 58;
}
break;
case 3:
kuukausi2 = 90;
break;
case 4:
kuukausi2 = 120;
break;
case 5:
kuukausi2 = 151;
break;
case 6:
kuukausi2 = 181;
break;
case 7:
kuukausi2 = 212;
break;
case 8:
kuukausi2 = 243;
break;
case 9:
kuukausi2 = 273;
break;
case 10:
kuukausi2 = 304;
break;
case 11:
kuukausi2 = 334;
break;
case 12:
kuukausi2 = 365;
break;
}
lukumaara = kuukausi - kuukausi2;
printf("Paivia yhteensa: \n");
printf("%d", lukumaara);
return (0);
}
int karkausvuosi (int vuosiluku)
{
int tulos;
if (vuosiluku % 4 == 0)
if (vuosiluku % 100 == 0)
if (vuosiluku % 400 == 0)
tulos = 1;
else
tulos = 0;
else
tulos = 1;
else
tulos = 0;
return(tulos);
}Pekkisp1978 kirjoitti:
No niin, yritetäänpä uudestaan. Ja pahoittelut epäselvyydestä. Eli tehtävänanto:
"Kirjoita c-kielinen ohjelma, jossa main-funktiossa luetaan vuosiluku ja kaksi kuukauden numeroa. Ohjelma tulostaa kyseisen vuoden kuukausien välisten päivien lukumäärän ko. kuukausien päivät mukaanluettuna. Ohjelmassa on otettava huomioon mahdollinen karkausvuosi".
Mikset vain switch-case rakenteen sijasta yksinkertaisesti käyttäisi taulukkoa tallentamaan päivät mitä kuukaudessa on ja silmukasssa laskisi näitä yhteen? Yksinkertaisinta olisi käyttää kahta taulukkoa, eli toiseen tallennettaisiin karkausvuoden kuukausien päivät.
Eli periaatteena siis:
int kuukaudet[] = { 31,28,31,30,31,30,31,31,30,31,30,31 };
int sum = 0;
int alku = 2;
int loppu = 3;
for(int i=alku-1; i<loppu; ++i) {
sum += kuukaudet[i];
}
printf("%d\n",sum);Karkausvuoteen tulee käyttää edellisessä tehtävässä rakennettua funktiota (joka minulla on tuossa koodissa). Taulukon käyttöä ei ole meille vielä opetettu. Päivien laskemiseen tulisi myös käyttää funktiota. (Funktiot on tämän harjoituskerran pääaihe).
Sinänsähän toi sun koko koodi vaikuttaa ihan hyvältä, joskin ilmeisesti on ajatusvirheitä kun tammikuussa kuukausi saa arvoksi 31 ja helmikuussa 87 tai 86, eli laskusysteemisi mukaan helmikuu olisi 56 tai 55 päivää pidempi kuin tammikuu, vaikka todellisuudessa ero on 28 tai 29 päivää. (Koodissa myös esiintyy 28 ja 27, vaikka tosiaan karkausvuotena helmikuu on päivän pidempi, ei lyhyempi)
Nyt huomionarvoista on myös, että karkausuvuoden laskua huomioidaan vain jos alku- tai loppukuukausi on 2, eli jos esimerkiksi annetut kuukaudet olisi 1 ja 4, niin karkausvuosi ei vaikuttaisi mitenkään tulokseen.
Itse tekisin koodin ilman taulukon käyttöä ehkä jotenkin näin. (Joskin itsestäni on ikävää toistaa samaa koodia kahteen kertaan niin laitoin päivämäärän laskun funktioon)
#include <stdio.h>
int karkausvuosi(int);
int pv(int,int);
int main(void)
{
int vuosiluku;
int kuukausi;
int kuukausi2;
int lukumaara;
printf("Anna vuosi> ");
scanf("%d", &vuosiluku);
printf("Anna kuukausi nro 1.> ");
scanf("%d", &kuukausi);
printf("Anna kuukausi nro 2.> ");
scanf("%d", &kuukausi2);
if (kuukausi <= kuukausi2) {
printf("Anna myohempi kuukausi ensin! ");
return 0;
}
printf("Paivia yhteensa: \n");
printf("%d", pv(kuukausi, vuosiluku)-pv(kuukausi2 - 1, vuosiluku));
return 0;
}
int pv(int kk, int vuosi) {
int res=0;
switch (kk) {
case 12: res+=31;
case 11: res+=30;
case 10: res+=31;
case 9: res+=30;
case 8: res+=31;
case 7: res+=31;
case 6: res+=30;
case 5: res+=31;
case 4: res+=30;
case 3: res+=31;
case 2: res+=28+karkausvuosi(vuosi);
case 1: res+=31;
}
return res;
}
int karkausvuosi (int vuosiluku)
{
if (vuosiluku % 4 != 0) return 0;
if (vuosiluku % 100 != 0) return 1;
if (vuosiluku % 400 != 0) return 0;
return 1;
}Pekkisp1978 kirjoitti:
Karkausvuoteen tulee käyttää edellisessä tehtävässä rakennettua funktiota (joka minulla on tuossa koodissa). Taulukon käyttöä ei ole meille vielä opetettu. Päivien laskemiseen tulisi myös käyttää funktiota. (Funktiot on tämän harjoituskerran pääaihe).
Grez antoi toimivan koodin, mikä käyttää C:n case rakenteen "fall thru" ominaisuutta hyväksi. Tätä pystytään hyödyntämään monissa sovelluksissa. Googlettamalla vaikka Duff's device voit lukea aiheesta lisää...
Omasta mielestäni tähän tehtävään taulukkoa käyttävä ratkaisu on kuitenkin tehokkaampi:
#include <stdio.h>
int days(int months[], int start, int end)
{
int sum = 0;
for(int i=start-1; i<end; ++i) {
sum += months[i];
}
return sum;
}
int karkausvuosi (int vuosiluku)
{
if (vuosiluku % 4 != 0) return 0;
if (vuosiluku % 100 != 0) return 1;
if (vuosiluku % 400 != 0) return 0;
return 1;
}
int main(void)
{
int kuukaudet1[] = { 31,28,31,30,31,30,31,31,30,31,30,31 };
int kuukaudet2[] = { 31,29,31,30,31,30,31,31,30,31,30,31 };
int vuosiluku;
int kuukausi;
int kuukausi2;
int lukumaara;
printf("Anna vuosi> ");
scanf("%d", &vuosiluku);
printf("Anna kuukausi nro 1.> ");
scanf("%d", &kuukausi);
printf("Anna kuukausi nro 2.> ");
scanf("%d", &kuukausi2);
if (kuukausi > kuukausi2) {
printf("Anna aiempi kuukausi ensin! ");
return 0;
}
if (karkausvuosi(vuosiluku))
lukumaara = days(kuukaudet2, kuukausi, kuukausi2);
else
lukumaara = days(kuukaudet1, kuukausi, kuukausi2);
printf("%d\n", lukumaara);
return 0;
}Näissä ohjelmointiharjoituksissa jaksetaan aina koodata tuo gregoriaaninen karkausvuosisääntö, johon kuuluu sadalla ja 400:lla jaollisuus.
Useimmilta jää huomaamatta, että juliaaninen neljällä jaollisuus riittäisi oikein hyvin, kunhan pysytään vuosien 1901 ja 2099 välillä, ja hyvin harva tietokoneohjelma koskaan käsittelee näiden ulkopuolella olevia päivämääriä.
Monissa maissa gregoriaaninen kalenteri otettiin käyttöön vasta 1900-luvulla, joten historiallisiin päivämääriinkään ei voi gregoriaanista sääntöä noin vain soveltaa.
Tronic kirjoitti:
Useimmilta jää huomaamatta, että juliaaninen neljällä jaollisuus riittäisi oikein hyvin, kunhan pysytään vuosien 1901 ja 2099 välillä, ja hyvin harva tietokoneohjelma koskaan käsittelee näiden ulkopuolella olevia päivämääriä.
Olen samaa mieltä!
Yksinkertainen ratkaisu ongelmaan voisi perustua kikkaan, jonka kehittelin 1970-luvulla millimetripaperilla ja viivoittimella: Paperilla oli vaaka-akselilla 12 kuukautta ja pystyakselilla 12 pistettä, kuukauden viimeiseen päivään saakka lasketut päivät vuoden alusta. Havaitsin, että viivoittimen voi asettaa niin, että se kulkee alle 0.5 päivän etäisyydellä kaikista pisteistä, tietenkin tammi-helmikuun aiheuttamaa siirtymää lukuunottamatta. Siitä syntyi seuraava funktio päiviä vuoden 1986 alusta laskevana versiona:
int date_days1986(int y, int m, int d)
{
d += (m * 30.575 - 30.075);
d += (y * 365.25 - 725386.24);
return d - (m <= 2) ? 1 : (y & 3) ? 3 : 2;
}Funktio muuntaa päivämäärän päiviksi vuoden 1986 alusta.
Koska funktio on C-kielinen, niin reaaliluvun katkaisua kokonaisluvuksi ei ole ollut tarpeellista merkitä.
Koodi toimii juuri tuolla Tronic:in mainitsemalla välillä vuoden 2099 joulukuuta lukuunottamatta.
Funktio lisää annettuun kuukauden päivään kuluvan vuoden aikaisempien kuukausien päivät ja edellisten vuosien päivät sekä tekee lopuksi pientä karkausvuoden ja helmikuun aiheuttamaa säätöä.
Tronic kirjoitti:
Näissä ohjelmointiharjoituksissa jaksetaan aina koodata tuo gregoriaaninen karkausvuosisääntö, johon kuuluu sadalla ja 400:lla jaollisuus.
Useimmilta jää huomaamatta, että juliaaninen neljällä jaollisuus riittäisi oikein hyvin, kunhan pysytään vuosien 1901 ja 2099 välillä, ja hyvin harva tietokoneohjelma koskaan käsittelee näiden ulkopuolella olevia päivämääriä.
Kannattaakohan triviaalia bugia kuitenkaan koodata ohjelmaan. (No ei.) Jos tekee tällaisia päätöksiä säästääkseen pari riviä koodia, niin silloin samaa kyseenalaista logiikkaa soveltanee monessa muussakin asiassa ja tulos on paskaa.
Kuten sanottu, tämä koodi oli tehty 1970-luvun alussa senaikaiselle tietokoneelle (HP 2000 Basic), jolloin iloittiin siitä, että tuhatluvun vaihtuessa ei tarvitsekaan välittää sataluvun vaihtumisesta.
Jokainen sana, mitä koodista voitiin pihistää, oli arvokas. Muuttujan testaus "if a = 0" oli kaksi sanaa lyhyempi jos sen kirjoitti "if not a". Koodaus oli tuolloin jatkuvaa taistelua muistitilan määrästä. Tätä ei tavallinen nykypäivän koodari voi varmaan ymmärtää.
Mikään koodaamisessa tehty ratkaisu ei ole bugi, jos ratkaisun vaikutuksen kertoo koodin reunaehdoissa.
Alchemist: Jos korjaisin tuon "triviaalin bugin", niin olisitko tyytyväinen vain, jos teen sen niin, että koodi toimii oikein vielä 1000 tai 2000 vuotta taaksepäin?
Matti Holopainen kirjoitti:
Alchemist: Jos korjaisin tuon "triviaalin bugin", niin olisitko tyytyväinen vain, jos teen sen niin, että koodi toimii oikein vielä 1000 tai 2000 vuotta taaksepäin?
En minä näe järkeä tehdä koodia, johon lisäillään tarkoituksellisesti bugeja vain koska koodari kuvittelee, ettei bugia "luultavasti koskaan" kohdata. Se on lyhytnäköistä ohjelmointia.
Aiemmin mainittu gregoriaanisen kalenterin soveltaminen historiallisiin päivämääriin eri alueilla on lokalisointiongelma, ei matemaattinen ongelma, eikä liity karkauspäivän laskemiseen millään tavoin.
En ymmärrä, mitä kyseisellä kommentilla edes haettiin, nimittäin jos käytät gregoriaanista kalenteria historiallisten aikojen esittämiseen, niin silloin karkausvuosi on otettava aina huomioon. Ja jos et käytä gregoriaanista kalenteria, niin silloin sen mukaisesta karkausvuodesta kiistely on yksinkertaisesti tyhmää. Karkauspäivä itsessään kuitenkin kuulunee muodossa tai toisessa tasan jokaiseen kalenteriin, sillä se on fysiikan lakien sanelema pakko.
Oma pointtini oli, että tuollainen käytös on älyllistä laiskuutta ja jos ihminen ei suhtaudu ohjelmointiin vakavasti, niin jälki on huonoa. Joudun kohtaamaan tällaisten ihmisten tekemää koodia työssäni päivittäin eikä sitä tunnu pääsevän pakoon edes työpaikkaa vaihtamalla, joten asialla on todellakin väliä. Ehkä vain triggeröidyin turhasta, mene ja tiedä.
Sitä paitsi jos kyse olisi useamman henkilön projektista, niin heti seuraava koodari, joka tarkastelee karkauspäivän laskevaa koodia, korjaisi tuon bugin pois. Se olisikin hauska nähdä, jos alkuperäinen tekijä kieltäytyisi hyväksymästä korjausta, koska hän itse lisäsi bugin tarkoituksella, kun eihän siihen koskaan elävässä elämässä törmää. (Ja sen jälkeen korjauksen tilalle kirjoitetaan kaksi kertaa pidempi selitys kommenttiin, että miksi koodia ei saa muuttaa.) Puhdasta typeryyttä.
P.S. En ymmärrä sinunkaan pointtiasi. Mitä tarkoittaa, että karkausvuoden laskeminen toimisi vain 1000 tai 2000 vuotta taaksepäin? Karkausvuoden laskemiseen ei ole muita sääntöjä kuin tässä ketjussa hyvin esiin tulleet jaollisuudet kolmen eri vuosiluvun suhteen. Jos noudatat näitä kolmea kriteeriä, niin voit laskea karkauspäivät taaksepäin vaikka alkuräjähdykseen asti.
The Alchemist kirjoitti:
En minä näe järkeä tehdä koodia, johon lisäillään tarkoituksellisesti bugeja vain koska koodari kuvittelee, ettei bugia "luultavasti koskaan" kohdata. Se on lyhytnäköistä ohjelmointia.
Minun mielestäni taas on ihan OK käyttää vaikkapa viikonpäivien laskemiseen nykyisiä gregoriaanisen kalenterin sääntöjä ja perustella ratkaisu sillä, että vaikka viikonpäivät menee joskus historiassa pieleen, niin sillä ei ole väliä, koska "bugia ei luultavasti koskaan kohdata". Minusta olisi pikemminkin tyhmää lähteä tekemään paljon* tarvittavia monimutkaisempia sääntöjä vaikka niitä ei luultavasti koskaan tarvittaisi.
* Itsekin olen sitä mieltä että gregoriaanisen kalenterin sääntöjä on järkevää käyttää sellaisinaan, koska ne ei ole paljon monimutkaisemmat kuin pelkkä neljällä -jaollisuus-tarkistus.
The Alchemist kirjoitti:
Aiemmin mainittu gregoriaanisen kalenterin soveltaminen historiallisiin päivämääriin eri alueilla on lokalisointiongelma, ei matemaattinen ongelma, eikä liity karkauspäivän laskemiseen millään tavoin.
Mielestäni ei liity mitenkään lokalisointiin, että gregoriaanista kalenteria ei voi soveltaa missään ennen vuotta 1582. Karkauspäivän laskemiseen asia liittyy sikäli, että karkauspäiviä oli sitä ennenkin.
The Alchemist kirjoitti:
Karkausvuoden laskemiseen ei ole muita sääntöjä kuin tässä ketjussa hyvin esiin tulleet jaollisuudet kolmen eri vuosiluvun suhteen. Jos noudatat näitä kolmea kriteeriä, niin voit laskea karkauspäivät taaksepäin vaikka alkuräjähdykseen asti.
Gregoriaanisen kalenterin säännöillä laskeminen on kyllä melko kyseenalaista ennen vuotta 1582, vähän sama kuin puhuisi YK:n toiminnasta ennen vuotta 1945.
Toki jos karkauspäiviä halutaan laskea esimerkiksi vuodenaikojen pitämiseksi synkassa kalenteriin, niin gregoriaanisen kalenterin laskusäännöt pelaa aika pitkälle, mutta ei kuitenkaan alkuräjähdykseen asti. Gregoriaanisen kalenterin laskusäännöillä vuoden keskipituus on 365,2425 kun taas vuoden oikea pituus on n. 365,2422 päivää. Eli jo miljoonien vuosien etäisyydelle laskettaessa ollaan todella pahasti pielessä. Perustellumpaa olisi käyttää suoraan tuota lukua 365,2422 mutta siitäkään ei ole todellista tietoa paljonko vuoden todellinen pituus on ollut vaikka 4 miljardia vuotta sitten ja voiko vuoden pituudesta puhuakaan ennen kuin maata on ollut olemassa.
Ainoa järkevä ja kommentoinnin arvoinen asia ylläolevassa viestissä oli analogia YK:hon. Asia on juurikin niin, ettei ole järkevää käyttää kalenterijärjestelmää sellaisiin vuosilukuihin, jolloin kyseisellä alueella käytettiin jotain vallan muuta kalenterijärjestelmää.
Kerroin kuitenkin jo aiemmin, ettei se vaikuta mitenkään siihen, mitkä ovat gregoriaanisen kalenterin laskusäännöt. Jos joku haluaa laskea gregoriaanisen kalenterin vuodelle 0004, niin sieltä löytyy karkauspäivä samoin kuin vuoden -1996 kalenteristakin.
The Alchemist kirjoitti:
Ainoa järkevä ja kommentoinnin arvoinen asia ylläolevassa viestissä oli...
Olisipa säästynyt aikaa, jos en olisi lainkaan kommentoinut noihin 01.11.2019 04:05:21 viestisi asioihin, missä ei ollut mitään järkeä. Kommenttini niihin sen sijaan oli perusteltuja ja järkeviä, vaikka et niitä nähtävästi ymmärtänytkään.
Muistakaa sitten käsitellä bugittomissa koodeissanne oikein myös vuodet ennen ajanlaskun alkua. 45, 41, ..., 1 eaa. olivat karkausvuosia, huomioiden ettei vuotta 0 ole lainkaan. Lisäksi vuosi 46 eaa. oli ainaki Roomassa 445 päivää pitkä, jotta sitä edeltänyt epäsäännöllinen ajanlasku saatiin tasattua auringon kanssa.
Koska maapallon kiertoaika auringon ja etenkin itsensä ympäri muuttuu hiljalleen, ei kannata luottaa gregoriaanisenkaan kalenterin kantavan ikuisesti, edes karkaussekunneilla ryyditettynä.
Olen kyllä samaa mieltä siitä että ohjelman rajoittaminen koodirivien säästämiseksi toimimaan vain päivämäärillä ennen vuotta 2099 on yleisesti ottaen typerää ellei sitten kyseessä ole kriittinen säästö muistissa. Otetaan esimerkiksi vaikka nettipankki. Esimerkiksi Säästöpankkiryhmä perustettiin vuonna 1823. Voidaan siis pitää täysin mahdollisena että kyseinen tai jokin toinen pankki on toiminnassa vielä vuonna 2100. Nettipankin bugi on korjattava jossakin vaiheessa, niin miksi kirjoittaa sitä alkuunkaan?
Itse olen sitä mieltä, että kannattaa miettiä kuinka iso vaiva on tehdä oikein.
Usein ei kannata tehdä vaikka viikon duunia varmistaakseen että joku äärimmäisen epätodennäköinenkin asia on otettu huomioon. Kutsuisin sitä turhaksi hifistelyksi.
Eli ilman muuta on järkevää koodata gregoriaanisen kalenterin säännöt, koska niiden parin jakojäännössäännön koodaamatta jättämisellä ei säästä merkittävää määrää työaikaa eikä nykyisellään merkittävää määrää konetehoa. Enemmän menee aikaa lähteä pohtimaan perusteluita miksi niitä ei sinne laittaisi.
Mutta se, että lähtisi toteuttamaan systeemiä joka laskee karkausvuoden oikein ennenkin gregoriaanisen kalenterin käyttöönottoa olisi vain ja ainoastaan tyhmää vaikkapa jossain verkkopankissa (eli ellei ole tekemässä järjestelmää nimenomaan historiallisten kalentereiden laskemista varten). Teoriassahan se verkkopankki sit vois laskea jotain väärin jos sinne syötettäisiin joku 1400 vuonna myönnetty laina, joka olis siirretty yrityskauppojen myötä tälle pankille. Todennäköisyys taitaa olla käytännössä 0 ja jos se sit ihmeen kautta tulis esille, niin ongelma voitaisiin kiertää pienehköllä vaivalla.
Itsellä on aika paljon kuluttajaelektroniikkalaitteita (tyyliin kahvinkeitin) jotka ei anna laittaa kelloa vuoteen 2100 asti. Ja niissä on tyypillisesti haluttu valita mieluummin 2 senttiä kuin 3 senttiä maksava mikrokontrolleri, niin saattaa olla että ohjelmamuistia on vaikkapa vain 256 sanaa. Tällaisessa en pitäisi syntinä laittaa karkausvuotta toimimaan pelkällä neljän jakojäännöksellä. Että sikäli Tronicillakin on erityistilanteissa pointti.
Kuluttajaelektroniikassa tuon nyt ymmärtää, kun sellaisten laitteiden odotettu käyttöikä on varmaan maksimissaan jotain 20 vuotta.
Lisäys: Toisaalta, jos samaa softaa halutaan käyttää myöhempään tuotteeseen niin tuollaisia bugeja tulisi välttää näissäkin tuotteissa.
Niin oletettavasti 20 vuotta myöhemmin tehtävässä tuotteessa olis joka tapauksessa järkevää kirjoittaa softa uusiksi. Riskihän siinä olis, että niin ei tajuta tehdä.
Grez kirjoitti:
Eli ilman muuta on järkevää koodata gregoriaanisen kalenterin säännöt, koska niiden parin jakojäännössäännön koodaamatta jättämisellä ei säästä merkittävää määrää työaikaa eikä nykyisellään merkittävää määrää konetehoa. Enemmän menee aikaa lähteä pohtimaan perusteluita miksi niitä ei sinne laittaisi.
Mutta se, että lähtisi toteuttamaan systeemiä joka laskee karkausvuoden oikein ennenkin gregoriaanisen kalenterin käyttöönottoa olisi vain ja ainoastaan tyhmää vaikkapa jossain verkkopankissa (eli ellei ole tekemässä järjestelmää nimenomaan historiallisten kalentereiden laskemista varten).
Sinä se jaksat ulista tästä historiallisesta yhteensopivuudesta vaikka karkausvuoden laskusääntö on sama sekä tulevaisuuteen ettei menneisyyteen päin. Siihen ei ole mitään poikkeuksia. Koodiin ei tarvitse tehdä mitään muutoksia, jotta se laskisi karkauspäivän mielivaltaiselle vuodelle oikein.
The Alchemist kirjoitti:
Sinä se jaksat ulista
Sinähän se täällä ainoa ulisija olet - tosin syy taitaa olla minun, kun en aina jaksa vääntää niin rautalangasta että sinäkin ymmärtäisit.
Tottakai, jos määrittelemme karkausvuoden laskusäännöksi nuo kolme jakojäännöstä, niin se laskusääntö laskee aina määritelmän mukaan oikein. Tottakai olet tuossa oikeassa - en ole koskaan muuta väittänytkään.
Aivan samoin jos määrittelisimme että karkausvuosi lasketaan vain ja ainoastaan neljän jakojäännöksellä, niin se laskusääntö laskisi aina määritelmän mukaan oikein. Ja tästähän sinä aloit itse ulisemaan, että vain idiootti tekee näin...
Kuitenkin ensimmäinen laskusääntö on validi vain sillä aikavälillä kun gregoriaaninen kalenteri on ollut voimassa aivan samoin kuin tuo jälkimmäinen sääntö on validi silloin kun Juliaaninen kalenteri oli käytössä ja esim. välillä 1901-2099.
Saat toki jatkaa ulinaa jos en vieläkään vääntänyt riittävästi rautalankaa.
Aihe on jo aika vanha, joten et voi enää vastata siihen.