Keskustelu: Yleinen keskustelu: Matemaattinen pähkinä

int lista[20] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};


for (int l=0;l<10000000;l++){

	lista[0] ++; //lisätään ensmimäisen alkion arvoa

	for(int i =0;i<20;i++) //käydään lista läpi
	{
		if (lista[i] == 92) //jos alkion arvo 92
		{
			lista[i] = 0; //laitetaan se 0
			lista[i+1] ++; //kasvatetaan seuraavan alkion arvoa
		}
	}

Listan arvo 10miljoonan kierroksen jälkeen:
59,42,76,11,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1

Osaisiko joku auttaa tekemään laskurin joka laskee listan alkioiden arvot tietyn määrää kierroksia jälkeen?

Tyyliin:
int* get_list(long long int iteration_index)
{

}

Minä osaan!

get_list =: 3 : '|. _1 + (20 $ 92) #: y'
get_list 10^7

Tuloste:

59 42 76 11 _1 _1 _1 _1 _1 _1 _1 _1 _1 _1 _1 _1 _1 _1 _1 _1

Täällä voi testata (paina oikealta "Run"): https://jsoftware.github.io/j-playground/bin/html2/#base64=Z2V0X2xpc3Qg­PTog­My­A6ICd8­Li­Bf­MSAr­ICgy­MCAk­IDky­KSAj­Oi­B5Jwpn­ZXRfb­Glzd­CAxMF43

Toteutus sisältää bugin, jonka löytämisen ja korjaamisen jätän sinulle harjoitukseksi.

92, 184, jne tosiaan on vähän ongelmallisia:

void get_list(int* list, long long int iteration_index)
{

	long long idx = iteration_index;
	int pos = 0;

	while (idx > 0 && pos < 20) {
		list[pos] = (idx % 92);
		list[pos] -=1;

		idx /= 92;
		pos++;
	}
}

8th:lla:

: get-list  \ n -- a
  [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1] const
  ( n:+ 92 n:/mod dup !if break then swap ) a:map= nip ;


: app:main
  10m get-list . cr ;

Tulostaa:

[59,42,76,11,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1]

jalski kirjoitti:

(25.09.2025 20:34:31): 8th:lla: – (koodia) – Tulostaa: ...

En jaksa 8th:ta ladata, mutta osaako tämä ottaa huomioon jos tuon 10m sijaan sinne viedäänkin vaikka 184?

Tää toimii jo melkein :D

void get_list(int* list, long long int iteration_index)
{

	long long idx = iteration_index;


	bool decrase = false;
	int pos = 0;

	while (idx > 0 && pos < 19) {
		list[pos] = (idx % 92);


		list[pos] -= 1;
		if (decrase) {
			list[pos] -= 1;
			decrase = false;
		}


		if (list[pos] <=-1) {
			list[pos] =  91;
			decrase = true;
		}

		idx /= 92;
		pos++;
	}
}

wy5vn kirjoitti:

En jaksa 8th:ta ladata, mutta osaako tämä ottaa huomioon jos tuon 10m sijaan sinne viedäänkin vaikka 184?

[91,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1]

Toimii

void get_list(int* list, long long int iteration_index)
{

	long long idx = iteration_index;
	int pos = 0;

	while (idx > 0 && pos < 20) {
		list[pos] =  (idx % 92);
		if (list[pos] == 0) {
			list[pos] = 91;
			return;
		}


		list[pos] -= 1;

		idx /= 92;
		pos++;
	}
}

Tässä varmaan oikeasti kannattaisi palauttaa myös jakojäännös...

Tavallaan tuossa tapahtuu niin, että kierrosmäärä muutetaan 92-järjestelmän luvuksi ja lisätään vialliseen 92-järjestelmän lukuun, jonka jokaisessa kohdassa on numero -1. Outo tilanne siis ylipäänsä. Tässä on koodi, joka tekee timenpiteen tehokkaammin.

#include <stdio.h>
int main() {
  int lista[] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
  const int koko = sizeof(lista) / sizeof(lista[0]);
  long kierroksia = 10000000;
  const int kantaluku = 92;

  long ylitys = kierroksia;
  for (int i = 0; i < koko && ylitys > 0; ++i) {
    long luku = (ylitys + lista[i]) / kantaluku;
    lista[i] += ylitys - luku * kantaluku;
    ylitys = luku;
    printf("%d ", lista[i]);
  }
  printf("\n");
}

jalski kirjoitti:

Tässä varmaan oikeasti kannattaisi palauttaa myös jakojäännös...

Miksi?

wy5vn kirjoitti:

jalski kirjoitti:

Tässä varmaan oikeasti kannattaisi palauttaa myös jakojäännös...

Miksi?

Meinasin vaan, että mikäli tästä tekee version mikä pystyy käsittelemään eri pituisia taulukkoja ja isoja lukuja, niin voisi olla hyvä palauttaa myös tieto ylivuodosta...

nii no joo