Mostra notizie nelle discussioni
  • Avatar
    Scritto da
    Non Autenticato
    il 2013-02-10 20:00:26.0 alle 2013-02-10 20:00:26.0
    java merda
    Ho bisogno di una matrice di queste dimensioni

    matrice[312500000][x]

    e oltre...

    Ma oltre un certo numero mi esce il seguente messaggio d'errore:

    Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    at combinazioni.Combinazioni.main

    Ovvero, lo spazio disponibile per la java virtual machine si esaurisce.

    È chiaro che nella programmazione si arriva spesso a lavorare con grandi numeri e quantità di dati consistenti; sto chiedendo troppo?

    C'è modo, comunque, di aumentare le dimensioni del heap space?
    • Avatar
      ☺
      Scritto da
      avvelentani
      Cubicolario
      il 2013-02-10 20:07:54.0 alle 2013-02-10 20:07:54.0
      Trollate totali: 18184
      Re: java merda
      Scritto da:
      > Ho bisogno di una matrice di queste dimensioni
      >
      > matrice[312500000][x]
      >
      > e oltre...
      >
      > Ma oltre un certo numero mi esce il seguente messaggio d'errore:
      >
      > Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
      > at combinazioni.Combinazioni.main
      >
      > Ovvero, lo spazio disponibile per la java virtual machine si esaurisce.
      >
      > È chiaro che nella programmazione si arriva spesso a lavorare con grandi numeri e quantità di dati consistenti; sto chiedendo troppo?
      >
      > C'è modo, comunque, di aumentare le dimensioni del heap space?

      l'opzione -Xmx ma con una matrice di quelle dimensioni devi sapere cosa stai facendo.

      **Modificato dall'autore il 10.02.2013 20:08**
      I think happiness is love
      - Vladimir Putin
    • Avatar
      ☺
      Scritto da
      The Lich
      Übermensch
      il 2013-02-10 20:13:15.0 alle 2013-02-10 20:13:15.0
      Trollate totali: 21351
      Re: java merda
      Scritto da:
      > Ho bisogno di una matrice di queste dimensioni
      >
      > matrice[312500000][x]
      >
      > e oltre...
      >
      > Ma oltre un certo numero mi esce il seguente messaggio d'errore:
      >
      > Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
      > at combinazioni.Combinazioni.main
      >
      > Ovvero, lo spazio disponibile per la java virtual machine si esaurisce.
      >
      > È chiaro che nella programmazione si arriva spesso a lavorare con grandi numeri e quantità di dati consistenti; sto chiedendo troppo?
      >
      > C'è modo, comunque, di aumentare le dimensioni del heap space?

      prova con questo:

      Immagine postata dall'utente

      The Lich™
      « Non è morto ciò che in eterno può attendere,
      e col passare di strani eoni, anche la morte può morire. »
      Cylon
      Immagine postata dall'utente
    • Avatar
      ☺
      Scritto da
      gengiva
      Utente privileggiato
      il 2013-02-10 20:38:07.0 alle 2013-02-10 20:38:07.0
      Trollate totali: 9100
      Re: java merda
      Scritto da:
      > Ho bisogno di una matrice di queste dimensioni
      >
      > matrice[312500000][x]
      >
      > e oltre...
      >
      > Ma oltre un certo numero mi esce il seguente messaggio d'errore:
      >
      > Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
      > at combinazioni.Combinazioni.main
      >
      > Ovvero, lo spazio disponibile per la java virtual machine si esaurisce.
      >
      > È chiaro che nella programmazione si arriva spesso a lavorare con grandi numeri e quantità di dati consistenti; sto chiedendo troppo?
      >
      > C'è modo, comunque, di aumentare le dimensioni del heap space?

      cosa stai programmandoNewbie, inesperto
      Cercatelo con Google, ritardato! ©
      • Avatar
        ☺
        Scritto da
        altg
        utente che non utiene
        il 2013-02-10 20:44:44.0 alle 2013-02-10 20:44:44.0
        Trollate totali: 11540
        Re: java merda
        > > Ho bisogno di una matrice di queste dimensioni
        > >
        > > matrice[312500000][x]
        > >
        > > e oltre...
        > >
        > > Ma oltre un certo numero mi esce il seguente messaggio d'errore:
        > >
        > > Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
        > > at combinazioni.Combinazioni.main
        > >
        > > Ovvero, lo spazio disponibile per la java virtual machine si esaurisce.
        > >
        > > È chiaro che nella programmazione si arriva spesso a lavorare con grandi numeri e quantità di dati consistenti; sto chiedendo troppo?
        > >
        > > C'è modo, comunque, di aumentare le dimensioni del heap space?
        >
        > cosa stai programmandoNewbie, inesperto

        3125 e` 5 alla quinta, dev'essere qualcosa di 5 o 6-dimensionale,
        contando anche quella x Fantasma

        aspe', contando gli zeri 50 alla quinta

        **Modificato dall'autore il 10.02.2013 20:47**
        • Avatar
          ☺
          Scritto da
          altg
          utente che non utiene
          il 2013-02-10 20:45:54.0 alle 2013-02-10 20:45:54.0
          Trollate totali: 11540
          Re: java merda
          > > > Ho bisogno di una matrice di queste dimensioni
          > > >
          > > > matrice[312500000][x]
          > > >
          > > > e oltre...
          > > >
          > > > Ma oltre un certo numero mi esce il seguente messaggio d'errore:
          > > >
          > > > Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
          > > > at combinazioni.Combinazioni.main
          > > >
          > > > Ovvero, lo spazio disponibile per la java virtual machine si esaurisce.
          > > >
          > > > È chiaro che nella programmazione si arriva spesso a lavorare con grandi numeri e quantità di dati consistenti; sto chiedendo troppo?
          > > >
          > > > C'è modo, comunque, di aumentare le dimensioni del heap space?
          > >
          > > cosa stai programmandoNewbie, inesperto
          >
          > 3125 e` 5 alla quinta, dev'essere qualcosa di 5 o 6-dimensionale,
          > contando anche quella x Fantasma

          Errore di sbaglio. Questo messaggio non vuol dire nulla. Triste

          **Modificato dall'autore il 10.02.2013 20:46**
        • Avatar
          ☺
          Scritto da
          gengiva
          Utente privileggiato
          il 2013-02-10 20:52:51.0 alle 2013-02-10 20:52:51.0
          Trollate totali: 9100
          Re: java merda
          Scritto da: altg
          > > > Ho bisogno di una matrice di queste dimensioni
          > > >
          > > > matrice[312500000][x]
          > > >
          > > > e oltre...
          > > >
          > > > Ma oltre un certo numero mi esce il seguente messaggio d'errore:
          > > >
          > > > Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
          > > > at combinazioni.Combinazioni.main
          > > >
          > > > Ovvero, lo spazio disponibile per la java virtual machine si esaurisce.
          > > >
          > > > È chiaro che nella programmazione si arriva spesso a lavorare con grandi numeri e quantità di dati consistenti; sto chiedendo troppo?
          > > >
          > > > C'è modo, comunque, di aumentare le dimensioni del heap space?
          > >
          > > cosa stai programmandoNewbie, inesperto
          >
          > 3125 e` 5 alla quinta, dev'essere qualcosa di 5 o 6-dimensionale,
          > contando anche quella x Fantasma
          >
          > aspe', contando gli zeri 50 alla quinta
          >
          > **Modificato dall'autore il 10.02.2013 20:47**

          to tieni

          Immagine postata dall'utente

          buon non compleanno A bocca storta
          Cercatelo con Google, ritardato! ©
          • Avatar
            ☺
            Scritto da
            altg
            utente che non utiene
            il 2013-02-10 20:58:19.0 alle 2013-02-10 20:58:19.0
            Trollate totali: 11540
            Re: java merda
            > > > > Ho bisogno di una matrice di queste dimensioni
            > > > >
            > > > > matrice[312500000][x]
            > > > >
            > > > > e oltre...
            > > > >
            > > > > Ma oltre un certo numero mi esce il seguente messaggio d'errore:
            > > > >
            > > > > Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
            > > > > at combinazioni.Combinazioni.main
            > > > >
            > > > > Ovvero, lo spazio disponibile per la java virtual machine si esaurisce.
            > > > >
            > > > > È chiaro che nella programmazione si arriva spesso a lavorare con grandi numeri e quantità di dati consistenti; sto chiedendo troppo?
            > > > >
            > > > > C'è modo, comunque, di aumentare le dimensioni del heap space?
            > > >
            > > > cosa stai programmandoNewbie, inesperto
            > >
            > > 3125 e` 5 alla quinta, dev'essere qualcosa di 5 o 6-dimensionale,
            > > contando anche quella x Fantasma
            > >
            > > aspe', contando gli zeri 50 alla quinta
            > >
            > > **Modificato dall'autore il 10.02.2013 20:47**
            >
            > to tieni
            >
            > Immagine postata dall'utente
            >
            > buon non compleanno A bocca storta

            Non m'e` mai riuscito un granche` fare i conti a mente. Anonimo
            Ho difficolta` perfino coi resti, a volte... In lacrime
            • Avatar
              ☺
              Scritto da
              ::1
              il 2013-02-10 21:01:53.0 alle 2013-02-10 21:01:53.0
              Trollate totali: 12321
              Re: java merda
              Scritto da: altg
              > > > > > Ho bisogno di una matrice di queste dimensioni
              > > > > >
              > > > > > matrice[312500000][x]
              > > > > >
              > > > > > e oltre...
              > > > > >
              > > > > > Ma oltre un certo numero mi esce il seguente messaggio d'errore:
              > > > > >
              > > > > > Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
              > > > > > at combinazioni.Combinazioni.main
              > > > > >
              > > > > > Ovvero, lo spazio disponibile per la java virtual machine si esaurisce.
              > > > > >
              > > > > > È chiaro che nella programmazione si arriva spesso a lavorare con grandi numeri e quantità di dati consistenti; sto chiedendo troppo?
              > > > > >
              > > > > > C'è modo, comunque, di aumentare le dimensioni del heap space?
              > > > >
              > > > > cosa stai programmandoNewbie, inesperto
              > > >
              > > > 3125 e` 5 alla quinta, dev'essere qualcosa di 5 o 6-dimensionale,
              > > > contando anche quella x Fantasma
              > > >
              > > > aspe', contando gli zeri 50 alla quinta
              > > >
              > > > **Modificato dall'autore il 10.02.2013 20:47**
              > >
              > > to tieni
              > >
              > > Immagine postata dall'utente
              > >
              > > buon non compleanno A bocca storta
              >
              > Non m'e` mai riuscito un granche` fare i conti a mente. Anonimo
              > Ho difficolta` perfino coi resti, a volte... In lacrime

              linoleum ce le ha le matrici?Newbie, inesperto
              Young professional woman and busy mom.
              • Avatar
                ☺
                Scritto da
                altg
                utente che non utiene
                il 2013-02-10 21:05:33.0 alle 2013-02-10 21:05:33.0
                Trollate totali: 11540
                Re: java merda
                > > > > > > Ho bisogno di una matrice di queste dimensioni
                > > > > > >
                > > > > > > matrice[312500000][x]
                > > > > > >
                > > > > > > e oltre...
                > > > > > >
                > > > > > > Ma oltre un certo numero mi esce il seguente messaggio d'errore:
                > > > > > >
                > > > > > > Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
                > > > > > > at combinazioni.Combinazioni.main
                > > > > > >
                > > > > > > Ovvero, lo spazio disponibile per la java virtual machine si esaurisce.
                > > > > > >
                > > > > > > È chiaro che nella programmazione si arriva spesso a lavorare con grandi numeri e quantità di dati consistenti; sto chiedendo troppo?
                > > > > > >
                > > > > > > C'è modo, comunque, di aumentare le dimensioni del heap space?
                > > > > >
                > > > > > cosa stai programmandoNewbie, inesperto
                > > > >
                > > > > 3125 e` 5 alla quinta, dev'essere qualcosa di 5 o 6-dimensionale,
                > > > > contando anche quella x Fantasma
                > > > >
                > > > > aspe', contando gli zeri 50 alla quinta
                > > > >
                > > > > **Modificato dall'autore il 10.02.2013 20:47**
                > > >
                > > > to tieni
                > > >
                > > > Immagine postata dall'utente
                > > >
                > > > buon non compleanno A bocca storta
                > >
                > > Non m'e` mai riuscito un granche` fare i conti a mente. Anonimo
                > > Ho difficolta` perfino coi resti, a volte... In lacrime
                >
                > linoleum ce le ha le matrici?Newbie, inesperto

                Oh si`.
                Tutte vettorializzate. Imbarazzato
                • Avatar
                  ☺
                  Scritto da
                  ::1
                  il 2013-02-10 21:07:28.0 alle 2013-02-10 21:07:28.0
                  Trollate totali: 12321
                  Re: java merda
                  > > linoleum ce le ha le matrici?Newbie, inesperto
                  >
                  > Oh si`.
                  > Tutte vettorializzate. Imbarazzato

                  Quindi per ottimizzare il programma di op basta usare linoleumIdea!
                  Young professional woman and busy mom.
                  • Avatar
                    ☺
                    Scritto da
                    altg
                    utente che non utiene
                    il 2013-02-10 21:28:25.0 alle 2013-02-10 21:28:25.0
                    Trollate totali: 11540
                    Re: java merda
                    > > > linoleum ce le ha le matrici?Newbie, inesperto
                    > >
                    > > Oh si`.
                    > > Tutte vettorializzate. Imbarazzato
                    >
                    > Quindi per ottimizzare il programma di op basta usare linoleumIdea!

                    Essenzialmente non sa cosa sia una matrice, l'unica cosa che conosce e` una sequenza di unita` di memoria, cosa c'e` dentro a ogni unita` non e` dichiarato se non nei commenti. I tipi non esistono, tuttavia c'e` la convenzione di indicare il ruolo di un simbolo per mezzo di una forma molto strana e generica di hungarian notation, facendo precedere il nome di un simbolo da una singola lettera, ad esempio:

                    h something = handle per qualcosa
                    p t message = puntatore a una stringa con un byte per carattere

                    f = flag, booleano
                    h = handle, puntatore a un puntatore
                    i = indice
                    m = bitmap (valore da interpretare bit-wisely)
                    n = numero di (intero positivo o nullo)
                    p = puntatore (seguito da altra lettera per indicare "a cosa")
                    q = numero in virgola mobile
                    r = range (allocato staticamente, quindi vettore o matrice)
                    s = stringa null-terminated (un carattere per unita`)
                    t = stringa null-terminated (un byte per unita`)
                    v = variabile (il tipo e` inconsistente, variabile o irrilevante)
                    z = numero intero con segno

                    al compilatore ovviamente non gliene frega nulla se questa notazione viene usata bene, male o per niente. E` solo un aiuto visivo.
      • Avatar
        Scritto da
        Non Autenticato
        il 2013-02-10 21:02:12.0 alle 2013-02-10 21:02:12.0
        Re: java merda
        Scritto da: gengiva
        > Scritto da:
        > > Ho bisogno di una matrice di queste dimensioni
        > >
        > > matrice[312500000][x]
        > >
        > > e oltre...
        > >
        > > Ma oltre un certo numero mi esce il seguente messaggio d'errore:
        > >
        > > Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
        > > at combinazioni.Combinazioni.main
        > >
        > > Ovvero, lo spazio disponibile per la java virtual machine si esaurisce.
        > >
        > > È chiaro che nella programmazione si arriva spesso a lavorare con grandi numeri e quantità di dati consistenti; sto chiedendo troppo?
        > >
        > > C'è modo, comunque, di aumentare le dimensioni del heap space?
        >
        > cosa stai programmandoNewbie, inesperto


        La matrice serve a memorizzare le n varianti di una data stringa.

        Esempio semplice: ho lo 0 e ho l'1.

        00
        01
        10
        11

        Ogni riga della matrice memorizza una variante.

        Il problema è che con stringhe molto grandi viene fuori una matrice enorme.
        • Avatar
          ☺
          Scritto da
          ::1
          il 2013-02-10 21:05:25.0 alle 2013-02-10 21:05:25.0
          Trollate totali: 12321
          Re: java merda
          Scritto da:
          > Scritto da: gengiva
          > > Scritto da:
          > > > Ho bisogno di una matrice di queste dimensioni
          > > >
          > > > matrice[312500000][x]
          > > >
          > > > e oltre...
          > > >
          > > > Ma oltre un certo numero mi esce il seguente messaggio d'errore:
          > > >
          > > > Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
          > > > at combinazioni.Combinazioni.main
          > > >
          > > > Ovvero, lo spazio disponibile per la java virtual machine si esaurisce.
          > > >
          > > > È chiaro che nella programmazione si arriva spesso a lavorare con grandi numeri e quantità di dati consistenti; sto chiedendo troppo?
          > > >
          > > > C'è modo, comunque, di aumentare le dimensioni del heap space?
          > >
          > > cosa stai programmandoNewbie, inesperto
          >
          >
          > La matrice serve a memorizzare le n varianti di una data stringa.
          >
          > Esempio semplice: ho lo 0 e ho l'1.
          >
          > 00
          > 01
          > 10
          > 11
          >
          > Ogni riga della matrice memorizza una variante.
          >
          > Il problema è che con stringhe molto grandi viene fuori una matrice enorme.

          Perché devi memorizzarle? Ripensa all'algoritmo, probabilmente riesci a fare quello che ti serve mentre le generi.
          Young professional woman and busy mom.
          • Avatar
            Scritto da
            Non Autenticato
            il 2013-02-11 01:29:30.0 alle 2013-02-11 01:29:30.0
            Re: java merda
            Scritto da: ::1
            > Scritto da:
            > > Scritto da: gengiva
            > > > Scritto da:
            > > > > Ho bisogno di una matrice di queste dimensioni
            > > > >
            > > > > matrice[312500000][x]
            > > > >
            > > > > e oltre...
            > > > >
            > > > > Ma oltre un certo numero mi esce il seguente messaggio d'errore:
            > > > >
            > > > > Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
            > > > > at combinazioni.Combinazioni.main
            > > > >
            > > > > Ovvero, lo spazio disponibile per la java virtual machine si esaurisce.
            > > > >
            > > > > È chiaro che nella programmazione si arriva spesso a lavorare con grandi numeri e quantità di dati consistenti; sto chiedendo troppo?
            > > > >
            > > > > C'è modo, comunque, di aumentare le dimensioni del heap space?
            > > >
            > > > cosa stai programmandoNewbie, inesperto
            > >
            > >
            > > La matrice serve a memorizzare le n varianti di una data stringa.
            > >
            > > Esempio semplice: ho lo 0 e ho l'1.
            > >
            > > 00
            > > 01
            > > 10
            > > 11
            > >
            > > Ogni riga della matrice memorizza una variante.
            > >
            > > Il problema è che con stringhe molto grandi viene fuori una matrice enorme.
            >
            > Perché devi memorizzarle? Ripensa all'algoritmo, probabilmente riesci a fare quello che ti serve mentre le generi.

            Non lo so, io quando programmo penso a quello che farei io come umano e poi lo faccio fare al pc.

            Io mi sono ispirato al metodo che uso per riempire le tabelle di verità dell'algebra di Boole.

            Prima cosa devi sapere il numero delle varianti possibili, quindi: numeroStringhe=rangeDiCaratteriUnicode*lunghezzaStringa

            Poi, la prima colonna contiene tutte le variabili che si ripetono ciclicamente in base a: ciclo=numeroStringhe/rangeDicaratteriUnicode

            La seconda colonna: ciclo=ciclo/rangeDicaratteriUnicode

            e così via...

            Rimpiendo le colonne in questo modo, riesci ad avere delle righe tutte diverse tra loro, quindi una matrice con tutte le possibili combinazioni.

            Esempio applicato alle tabelle di verità: mettiamo che la variabili sono tre, e ovviamente i loro possibili valori 0 o 1.

            23=8

            8/2= 4

            Quindi, prima colonna:

            0
            0
            0
            0
            1
            1
            1
            1

            Seconda colonna:

            0
            0
            1
            1
            0
            0
            1
            1

            Terza colonna

            0
            1
            0
            1
            0
            1
            0
            1

            Tabella:

            000
            001
            010
            011
            100
            101
            110
            111


            Metodo infallibile per avere tutte le varianti, e ho subito pensato a una matrice.

            Forse riesco a gestirlo con una semplice "print", ci penserò...




            • Avatar
              ☺
              Scritto da
              ::1
              il 2013-02-11 08:01:10.0 alle 2013-02-11 08:01:10.0
              Trollate totali: 12321
              Re: java merda
              Scritto da:
              > Scritto da: ::1
              > > Perché devi memorizzarle? Ripensa all'algoritmo, probabilmente riesci a fare quello che ti serve mentre le generi.
              >
              > Non lo so, io quando programmo penso a quello che farei io come umano e poi lo faccio fare al pc.

              Purtroppo i computer non funzionano così (oddio, forse prolog sì).
              Young professional woman and busy mom.
            • Avatar
              Scritto da
              Non Autenticato
              il 2013-02-11 11:02:24.0 alle 2013-02-11 11:02:24.0
              Re: java merda
              > > > > > Ho bisogno di una matrice di queste dimensioni
              > > > > >
              > > > > > matrice[312500000][x]
              > > > > >
              > > > > > e oltre...
              > > > > >
              > > > > > Ma oltre un certo numero mi esce il seguente messaggio d'errore:
              > > > > >
              > > > > > Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
              > > > > > at combinazioni.Combinazioni.main
              > > > > >
              > > > > > Ovvero, lo spazio disponibile per la java virtual machine si esaurisce.
              > > > > >
              > > > > > È chiaro che nella programmazione si arriva spesso a lavorare con grandi numeri e quantità di dati consistenti; sto chiedendo troppo?
              > > > > >
              > > > > > C'è modo, comunque, di aumentare le dimensioni del heap space?
              > > > >
              > > > > cosa stai programmandoNewbie, inesperto
              > > >
              > > >
              > > > La matrice serve a memorizzare le n varianti di una data stringa.
              > > >
              > > > Esempio semplice: ho lo 0 e ho l'1.
              > > >
              > > > 00
              > > > 01
              > > > 10
              > > > 11
              > > >
              > > > Ogni riga della matrice memorizza una variante.
              > > >
              > > > Il problema è che con stringhe molto grandi viene fuori una matrice enorme.
              > >
              > > Perché devi memorizzarle? Ripensa all'algoritmo, probabilmente riesci a fare quello che ti serve mentre le generi.
              >
              > Non lo so, io quando programmo penso a quello che farei io come umano e poi lo faccio fare al pc.
              >
              > Io mi sono ispirato al metodo che uso per riempire le tabelle di verità dell'algebra di Boole.
              >
              > Prima cosa devi sapere il numero delle varianti possibili, quindi: numeroStringhe=rangeDiCaratteriUnicode*lunghezzaStringa
              >
              > Poi, la prima colonna contiene tutte le variabili che si ripetono ciclicamente in base a: ciclo=numeroStringhe/rangeDicaratteriUnicode
              >
              > La seconda colonna: ciclo=ciclo/rangeDicaratteriUnicode
              >
              > e così via...
              >
              > Rimpiendo le colonne in questo modo, riesci ad avere delle righe tutte diverse tra loro, quindi una matrice con tutte le possibili combinazioni.
              >
              > Esempio applicato alle tabelle di verità: mettiamo che la variabili sono tre, e ovviamente i loro possibili valori 0 o 1.
              >
              > 23=8
              >
              > 8/2= 4
              >
              > Quindi, prima colonna:
              >
              > 0
              > 0
              > 0
              > 0
              > 1
              > 1
              > 1
              > 1
              >
              > Seconda colonna:
              >
              > 0
              > 0
              > 1
              > 1
              > 0
              > 0
              > 1
              > 1
              >
              > Terza colonna
              >
              > 0
              > 1
              > 0
              > 1
              > 0
              > 1
              > 0
              > 1
              >
              > Tabella:
              >
              > 000
              > 001
              > 010
              > 011
              > 100
              > 101
              > 110
              > 111
              >
              >
              > Metodo infallibile per avere tutte le varianti, e ho subito pensato a una matrice.
              >
              > Forse riesco a gestirlo con una semplice "print", ci penserò...
              >
              >
              >
              >
              >

              Ma cosa vuoi fare? Ottenere le combinazioni (con ripetizione) di n elementi a k per volta - ovvero di k elementi presi in un insieme di n?
              • Avatar
                Scritto da
                Non Autenticato
                il 2013-02-11 11:19:42.0 alle 2013-02-11 11:19:42.0
                Re: java merda
                Scritto da:
                > > > > > > Ho bisogno di una matrice di queste dimensioni
                > > > > > >
                > > > > > > matrice[312500000][x]
                > > > > > >
                > > > > > > e oltre...
                > > > > > >
                > > > > > > Ma oltre un certo numero mi esce il seguente messaggio d'errore:
                > > > > > >
                > > > > > > Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
                > > > > > > at combinazioni.Combinazioni.main
                > > > > > >
                > > > > > > Ovvero, lo spazio disponibile per la java virtual machine si esaurisce.
                > > > > > >
                > > > > > > È chiaro che nella programmazione si arriva spesso a lavorare con grandi numeri e quantità di dati consistenti; sto chiedendo troppo?
                > > > > > >
                > > > > > > C'è modo, comunque, di aumentare le dimensioni del heap space?
                > > > > >
                > > > > > cosa stai programmandoNewbie, inesperto
                > > > >
                > > > >
                > > > > La matrice serve a memorizzare le n varianti di una data stringa.
                > > > >
                > > > > Esempio semplice: ho lo 0 e ho l'1.
                > > > >
                > > > > 00
                > > > > 01
                > > > > 10
                > > > > 11
                > > > >
                > > > > Ogni riga della matrice memorizza una variante.
                > > > >
                > > > > Il problema è che con stringhe molto grandi viene fuori una matrice enorme.
                > > >
                > > > Perché devi memorizzarle? Ripensa all'algoritmo, probabilmente riesci a fare quello che ti serve mentre le generi.
                > >
                > > Non lo so, io quando programmo penso a quello che farei io come umano e poi lo faccio fare al pc.
                > >
                > > Io mi sono ispirato al metodo che uso per riempire le tabelle di verità dell'algebra di Boole.
                > >
                > > Prima cosa devi sapere il numero delle varianti possibili, quindi: numeroStringhe=rangeDiCaratteriUnicode*lunghezzaStringa
                > >
                > > Poi, la prima colonna contiene tutte le variabili che si ripetono ciclicamente in base a: ciclo=numeroStringhe/rangeDicaratteriUnicode
                > >
                > > La seconda colonna: ciclo=ciclo/rangeDicaratteriUnicode
                > >
                > > e così via...
                > >
                > > Rimpiendo le colonne in questo modo, riesci ad avere delle righe tutte diverse tra loro, quindi una matrice con tutte le possibili combinazioni.
                > >
                > > Esempio applicato alle tabelle di verità: mettiamo che la variabili sono tre, e ovviamente i loro possibili valori 0 o 1.
                > >
                > > 23=8
                > >
                > > 8/2= 4
                > >
                > > Quindi, prima colonna:
                > >
                > > 0
                > > 0
                > > 0
                > > 0
                > > 1
                > > 1
                > > 1
                > > 1
                > >
                > > Seconda colonna:
                > >
                > > 0
                > > 0
                > > 1
                > > 1
                > > 0
                > > 0
                > > 1
                > > 1
                > >
                > > Terza colonna
                > >
                > > 0
                > > 1
                > > 0
                > > 1
                > > 0
                > > 1
                > > 0
                > > 1
                > >
                > > Tabella:
                > >
                > > 000
                > > 001
                > > 010
                > > 011
                > > 100
                > > 101
                > > 110
                > > 111
                > >
                > >
                > > Metodo infallibile per avere tutte le varianti, e ho subito pensato a una matrice.
                > >
                > > Forse riesco a gestirlo con una semplice "print", ci penserò...
                > >
                > >
                > >
                > >
                > >
                >
                > Ma cosa vuoi fare? Ottenere le combinazioni (con ripetizione) di n elementi a k per volta - ovvero di k elementi presi in un insieme di n?


                In termini matematici, e più precisamente del calcolo combinatorio, stiamo parlando di "disposizioni con ripetizione", ovvero le disposizioni degli elementi di un insieme nel caso in cui un elemento dell'insieme possa essere "ripescato" più volte.
                IL caso contrapposto è quello delle "disposizioni semplici", in cui un elemento può essere pescato una sola volta dall'insieme.

                Per le disposizioni con ripetizione il calcolo è: numeroElementiInsiemelunghezzaStringa

                che è poi quello che si fa per sapere quanti valori può rappresentare una stringa di bit.


                Quindi la mia matrice ha dimensioni esponenzialmente crescenti a dipendenza della lunghezza della stringa; già solo con 5 caratteri: 312500000 (righe).

                Comunque ho pensato che potrei modificare l'algoritmo in maniera tale da utilizzare una matrice piccola come memoria temporanea, che poi viene resettata e riutilizzata.
                O se no trovando l'algoritmo per lavorare sulle righe anziché sulle colonne potrei anche fare a meno di una matrice; il problema è che io non conosco un altro metodo efficace per scrivere le n disposizioni degli elementi di un insieme.
                • Avatar
                  Scritto da
                  Non Autenticato
                  il 2013-02-11 11:28:07.0 alle 2013-02-11 11:28:07.0
                  Re: java merda
                  > > > > > > > Ho bisogno di una matrice di queste dimensioni
                  > > > > > > >
                  > > > > > > > matrice[312500000][x]
                  > > > > > > >
                  > > > > > > > e oltre...
                  > > > > > > >
                  > > > > > > > Ma oltre un certo numero mi esce il seguente messaggio d'errore:
                  > > > > > > >
                  > > > > > > > Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
                  > > > > > > > at combinazioni.Combinazioni.main
                  > > > > > > >
                  > > > > > > > Ovvero, lo spazio disponibile per la java virtual machine si esaurisce.
                  > > > > > > >
                  > > > > > > > È chiaro che nella programmazione si arriva spesso a lavorare con grandi numeri e quantità di dati consistenti; sto chiedendo troppo?
                  > > > > > > >
                  > > > > > > > C'è modo, comunque, di aumentare le dimensioni del heap space?
                  > > > > > >
                  > > > > > > cosa stai programmandoNewbie, inesperto
                  > > > > >
                  > > > > >
                  > > > > > La matrice serve a memorizzare le n varianti di una data stringa.
                  > > > > >
                  > > > > > Esempio semplice: ho lo 0 e ho l'1.
                  > > > > >
                  > > > > > 00
                  > > > > > 01
                  > > > > > 10
                  > > > > > 11
                  > > > > >
                  > > > > > Ogni riga della matrice memorizza una variante.
                  > > > > >
                  > > > > > Il problema è che con stringhe molto grandi viene fuori una matrice enorme.
                  > > > >
                  > > > > Perché devi memorizzarle? Ripensa all'algoritmo, probabilmente riesci a fare quello che ti serve mentre le generi.
                  > > >
                  > > > Non lo so, io quando programmo penso a quello che farei io come umano e poi lo faccio fare al pc.
                  > > >
                  > > > Io mi sono ispirato al metodo che uso per riempire le tabelle di verità dell'algebra di Boole.
                  > > >
                  > > > Prima cosa devi sapere il numero delle varianti possibili, quindi: numeroStringhe=rangeDiCaratteriUnicode*lunghezzaStringa
                  > > >
                  > > > Poi, la prima colonna contiene tutte le variabili che si ripetono ciclicamente in base a: ciclo=numeroStringhe/rangeDicaratteriUnicode
                  > > >
                  > > > La seconda colonna: ciclo=ciclo/rangeDicaratteriUnicode
                  > > >
                  > > > e così via...
                  > > >
                  > > > Rimpiendo le colonne in questo modo, riesci ad avere delle righe tutte diverse tra loro, quindi una matrice con tutte le possibili combinazioni.
                  > > >
                  > > > Esempio applicato alle tabelle di verità: mettiamo che la variabili sono tre, e ovviamente i loro possibili valori 0 o 1.
                  > > >
                  > > > 23=8
                  > > >
                  > > > 8/2= 4
                  > > >
                  > > > Quindi, prima colonna:
                  > > >
                  > > > 0
                  > > > 0
                  > > > 0
                  > > > 0
                  > > > 1
                  > > > 1
                  > > > 1
                  > > > 1
                  > > >
                  > > > Seconda colonna:
                  > > >
                  > > > 0
                  > > > 0
                  > > > 1
                  > > > 1
                  > > > 0
                  > > > 0
                  > > > 1
                  > > > 1
                  > > >
                  > > > Terza colonna
                  > > >
                  > > > 0
                  > > > 1
                  > > > 0
                  > > > 1
                  > > > 0
                  > > > 1
                  > > > 0
                  > > > 1
                  > > >
                  > > > Tabella:
                  > > >
                  > > > 000
                  > > > 001
                  > > > 010
                  > > > 011
                  > > > 100
                  > > > 101
                  > > > 110
                  > > > 111
                  > > >
                  > > >
                  > > > Metodo infallibile per avere tutte le varianti, e ho subito pensato a una matrice.
                  > > >
                  > > > Forse riesco a gestirlo con una semplice "print", ci penserò...
                  > > >
                  > > >
                  > > >
                  > > >
                  > > >
                  > >
                  > > Ma cosa vuoi fare? Ottenere le combinazioni (con ripetizione) di n elementi a k per volta - ovvero di k elementi presi in un insieme di n?
                  >
                  >
                  > In termini matematici, e più precisamente del calcolo combinatorio, stiamo parlando di "disposizioni con ripetizione", ovvero le disposizioni degli elementi di un insieme nel caso in cui un elemento dell'insieme possa essere "ripescato" più volte.
                  > IL caso contrapposto è quello delle "disposizioni semplici", in cui un elemento può essere pescato una sola volta dall'insieme.

                  Boh, noi all'università le abbiamo chiamate combinazioni. Però era Analisi II, non un corso specificatamente dedicato al calcolo combinatorio.

                  > Per le disposizioni con ripetizione il calcolo è: numeroElementiInsiemelunghezzaStringa
                  >
                  > che è poi quello che si fa per sapere quanti valori può rappresentare una stringa di bit.
                  >
                  >
                  > Quindi la mia matrice ha dimensioni esponenzialmente crescenti a dipendenza della lunghezza della stringa; già solo con 5 caratteri: 312500000 (righe).
                  >
                  > Comunque ho pensato che potrei modificare l'algoritmo in maniera tale da utilizzare una matrice piccola come memoria temporanea, che poi viene resettata e riutilizzata.
                  > O se no trovando l'algoritmo per lavorare sulle righe anziché sulle colonne potrei anche fare a meno di una matrice; il problema è che io non conosco un altro metodo efficace per scrivere le n disposizioni degli elementi di un insieme.

                  la possibilità di fare a meno di esplicitare tutti gli elementi dipende da cosa vuoi farci.
                  • Avatar
                    Scritto da
                    Non Autenticato
                    il 2013-02-11 13:26:16.0 alle 2013-02-11 13:26:16.0
                    Re: java merda
                    Scritto da:
                    >
                    > Boh, noi all'università le abbiamo chiamate combinazioni. Però era Analisi II, non un corso specificatamente dedicato al calcolo combinatorio.
                    >

                    Ti stai confondendo, le combinazioni sono un altro concetto del calcolo combinatorio.

                    Mentre nelle disposizioni conta l'ordine degli elementi, nelle combinazioni conta solo la presenza.

                    Quindi le stringhe: "abc" e "acb" nelle combinazioni sono la stessa cosa, mentre nelle disposizioni no.

                    Disposizioni semplici, disposizioni con ripetizioni, combinazioni semplici e combinazioni con ripetizioni, permutazioni,permutazioni con ripetizione, permutazioni circolari.

                    Sono i casi classici del calcolo combinatorio, e ognuno ha la sua rispettiva formula.



                    • Avatar
                      Scritto da
                      Non Autenticato
                      il 2013-02-11 14:05:09.0 alle 2013-02-11 14:05:09.0
                      Re: java merda
                      > > Boh, noi all'università le abbiamo chiamate combinazioni. Però era Analisi II, non un corso specificatamente dedicato al calcolo combinatorio.
                      > >
                      >
                      > Ti stai confondendo, le combinazioni sono un altro concetto del calcolo combinatorio.
                      >
                      > Mentre nelle disposizioni conta l'ordine degli elementi, nelle combinazioni conta solo la presenza.
                      >
                      > Quindi le stringhe: "abc" e "acb" nelle combinazioni sono la stessa cosa, mentre nelle disposizioni no.
                      >
                      > Disposizioni semplici, disposizioni con ripetizioni, combinazioni semplici e combinazioni con ripetizioni, permutazioni,permutazioni con ripetizione, permutazioni circolari.
                      >
                      > Sono i casi classici del calcolo combinatorio, e ognuno ha la sua rispettiva formula.

                      Più che confondendo è che proprio non mi è stata insegnata la corretta terminologia. Conta comunque che nel linguaggio comune la combinazione di una cassaforte è una stringa in cui l'ordine degli elementi conta, il che aggiunge combustibile alla confusione.

                      Comunque se quello che vuoi fare fosse, che ne so, stampare tutte le disposizioni in un file o su un rotolo da sfoggiare in bagno, oppure eseguire dei calcoli su ciascuna di esse, non è necessario sistemarle preventivamente in un array, che prima o poi sfonda la memoria assegnata al processo, ma puoi farlo una alla volta cercando un algoritmo che calcoli una disposizione da quella precedente.
                      Ad esempio, tiro a indovinare, con una funzione ricorsiva che alla dimensione k della stringa chiama se stessa con dimensione k-1 fino ad arrivare a k=1. Facile dirlo, ma su questo forum c'è anche chi sa farlo.

                      Però per curiosità, si può sapere a cosa stai lavorando o è un segreto perché pensi di guadagnarci in borsa o di vincere il premio Nobel?
                      • Avatar
                        Scritto da
                        Non Autenticato
                        il 2013-02-11 20:55:30.0 alle 2013-02-11 20:55:30.0
                        Re: java merda
                        Scritto da:
                        >
                        > Però per curiosità, si può sapere a cosa stai lavorando o è un segreto perché pensi di guadagnarci in borsa o di vincere il premio Nobel?

                        Per ORA lo faccio solo per curiosità... ma un progetto più ampio nel futuro c'è. Fantasma
                        • Avatar
                          Scritto da
                          Non Autenticato
                          il 2013-02-11 21:10:27.0 alle 2013-02-11 21:10:27.0
                          Re: java merda
                          > > Però per curiosità, si può sapere a cosa stai lavorando o è un segreto perché pensi di guadagnarci in borsa o di vincere il premio Nobel?
                          >
                          > Per ORA lo faccio solo per curiosità... ma un progetto più ampio nel futuro c'è. Fantasma

                          Se ce lo dici ti aiutiamo in cambio di una menzione come coautori. Ficoso
                          • Avatar
                            Scritto da
                            Non Autenticato
                            il 2013-02-12 10:55:21.0 alle 2013-02-12 10:55:21.0
                            Re: java merda
                            Scritto da:
                            > > > Però per curiosità, si può sapere a cosa stai lavorando o è un segreto perché pensi di guadagnarci in borsa o di vincere il premio Nobel?
                            > >
                            > > Per ORA lo faccio solo per curiosità... ma un progetto più ampio nel futuro c'è. Fantasma
                            >
                            > Se ce lo dici ti aiutiamo in cambio di una menzione come coautori. Ficoso

                            Se tu fossi un bambino biondo con gli occhi smeraldo probabilmente riusciresti a convincermi. Ficoso
              • Avatar
                ☺
                Scritto da
                The Lich
                Übermensch
                il 2013-02-12 13:04:50.0 alle 2013-02-12 13:04:50.0
                Trollate totali: 21351
                Re: java merda
                Scritto da:
                > > > > > > Ho bisogno di una matrice di queste dimensioni
                > > > > > >
                > > > > > > matrice[312500000][x]
                > > > > > >
                > > > > > > e oltre...
                > > > > > >
                > > > > > > Ma oltre un certo numero mi esce il seguente messaggio d'errore:
                > > > > > >
                > > > > > > Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
                > > > > > > at combinazioni.Combinazioni.main
                > > > > > >
                > > > > > > Ovvero, lo spazio disponibile per la java virtual machine si esaurisce.
                > > > > > >
                > > > > > > È chiaro che nella programmazione si arriva spesso a lavorare con grandi numeri e quantità di dati consistenti; sto chiedendo troppo?
                > > > > > >
                > > > > > > C'è modo, comunque, di aumentare le dimensioni del heap space?
                > > > > >
                > > > > > cosa stai programmandoNewbie, inesperto
                > > > >
                > > > >
                > > > > La matrice serve a memorizzare le n varianti di una data stringa.
                > > > >
                > > > > Esempio semplice: ho lo 0 e ho l'1.
                > > > >
                > > > > 00
                > > > > 01
                > > > > 10
                > > > > 11
                > > > >
                > > > > Ogni riga della matrice memorizza una variante.
                > > > >
                > > > > Il problema è che con stringhe molto grandi viene fuori una matrice enorme.
                > > >
                > > > Perché devi memorizzarle? Ripensa all'algoritmo, probabilmente riesci a fare quello che ti serve mentre le generi.
                > >
                > > Non lo so, io quando programmo penso a quello che farei io come umano e poi lo faccio fare al pc.
                > >
                > > Io mi sono ispirato al metodo che uso per riempire le tabelle di verità dell'algebra di Boole.
                > >
                > > Prima cosa devi sapere il numero delle varianti possibili, quindi: numeroStringhe=rangeDiCaratteriUnicode*lunghezzaStringa
                > >
                > > Poi, la prima colonna contiene tutte le variabili che si ripetono ciclicamente in base a: ciclo=numeroStringhe/rangeDicaratteriUnicode
                > >
                > > La seconda colonna: ciclo=ciclo/rangeDicaratteriUnicode
                > >
                > > e così via...
                > >
                > > Rimpiendo le colonne in questo modo, riesci ad avere delle righe tutte diverse tra loro, quindi una matrice con tutte le possibili combinazioni.
                > >
                > > Esempio applicato alle tabelle di verità: mettiamo che la variabili sono tre, e ovviamente i loro possibili valori 0 o 1.
                > >
                > > 23=8
                > >
                > > 8/2= 4
                > >
                > > Quindi, prima colonna:
                > >
                > > 0
                > > 0
                > > 0
                > > 0
                > > 1
                > > 1
                > > 1
                > > 1
                > >
                > > Seconda colonna:
                > >
                > > 0
                > > 0
                > > 1
                > > 1
                > > 0
                > > 0
                > > 1
                > > 1
                > >
                > > Terza colonna
                > >
                > > 0
                > > 1
                > > 0
                > > 1
                > > 0
                > > 1
                > > 0
                > > 1
                > >
                > > Tabella:
                > >
                > > 000
                > > 001
                > > 010
                > > 011
                > > 100
                > > 101
                > > 110
                > > 111
                > >
                > >
                > > Metodo infallibile per avere tutte le varianti, e ho subito pensato a una matrice.
                > >
                > > Forse riesco a gestirlo con una semplice "print", ci penserò...
                > >
                > >
                > >
                > >
                > >
                >
                > Ma cosa vuoi fare? Ottenere le combinazioni (con ripetizione) di n elementi a k per volta - ovvero di k elementi presi in un insieme di n?

                la domanda corretta è: ma ti servono tutte in una volta?

                The Lich™
                « Non è morto ciò che in eterno può attendere,
                e col passare di strani eoni, anche la morte può morire. »
                Cylon
                Immagine postata dall'utente
                • Avatar
                  Scritto da
                  Non Autenticato
                  il 2013-02-12 14:26:40.0 alle 2013-02-12 14:26:40.0
                  Re: java merda
                  > > > > > > > Ho bisogno di una matrice di queste dimensioni
                  > > > > > > >
                  > > > > > > > matrice[312500000][x]
                  > > > > > > >
                  > > > > > > > e oltre...
                  > > > > > > >
                  > > > > > > > Ma oltre un certo numero mi esce il seguente messaggio d'errore:
                  > > > > > > >
                  > > > > > > > Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
                  > > > > > > > at combinazioni.Combinazioni.main
                  > > > > > > >
                  > > > > > > > Ovvero, lo spazio disponibile per la java virtual machine si esaurisce.
                  > > > > > > >
                  > > > > > > > È chiaro che nella programmazione si arriva spesso a lavorare con grandi numeri e quantità di dati consistenti; sto chiedendo troppo?
                  > > > > > > >
                  > > > > > > > C'è modo, comunque, di aumentare le dimensioni del heap space?
                  > > > > > >
                  > > > > > > cosa stai programmandoNewbie, inesperto
                  > > > > >
                  > > > > >
                  > > > > > La matrice serve a memorizzare le n varianti di una data stringa.
                  > > > > >
                  > > > > > Esempio semplice: ho lo 0 e ho l'1.
                  > > > > >
                  > > > > > 00
                  > > > > > 01
                  > > > > > 10
                  > > > > > 11
                  > > > > >
                  > > > > > Ogni riga della matrice memorizza una variante.
                  > > > > >
                  > > > > > Il problema è che con stringhe molto grandi viene fuori una matrice enorme.
                  > > > >
                  > > > > Perché devi memorizzarle? Ripensa all'algoritmo, probabilmente riesci a fare quello che ti serve mentre le generi.
                  > > >
                  > > > Non lo so, io quando programmo penso a quello che farei io come umano e poi lo faccio fare al pc.
                  > > >
                  > > > Io mi sono ispirato al metodo che uso per riempire le tabelle di verità dell'algebra di Boole.
                  > > >
                  > > > Prima cosa devi sapere il numero delle varianti possibili, quindi: numeroStringhe=rangeDiCaratteriUnicode*lunghezzaStringa
                  > > >
                  > > > Poi, la prima colonna contiene tutte le variabili che si ripetono ciclicamente in base a: ciclo=numeroStringhe/rangeDicaratteriUnicode
                  > > >
                  > > > La seconda colonna: ciclo=ciclo/rangeDicaratteriUnicode
                  > > >
                  > > > e così via...
                  > > >
                  > > > Rimpiendo le colonne in questo modo, riesci ad avere delle righe tutte diverse tra loro, quindi una matrice con tutte le possibili combinazioni.
                  > > >
                  > > > Esempio applicato alle tabelle di verità: mettiamo che la variabili sono tre, e ovviamente i loro possibili valori 0 o 1.
                  > > >
                  > > > 23=8
                  > > >
                  > > > 8/2= 4
                  > > >
                  > > > Quindi, prima colonna:
                  > > >
                  > > > 0
                  > > > 0
                  > > > 0
                  > > > 0
                  > > > 1
                  > > > 1
                  > > > 1
                  > > > 1
                  > > >
                  > > > Seconda colonna:
                  > > >
                  > > > 0
                  > > > 0
                  > > > 1
                  > > > 1
                  > > > 0
                  > > > 0
                  > > > 1
                  > > > 1
                  > > >
                  > > > Terza colonna
                  > > >
                  > > > 0
                  > > > 1
                  > > > 0
                  > > > 1
                  > > > 0
                  > > > 1
                  > > > 0
                  > > > 1
                  > > >
                  > > > Tabella:
                  > > >
                  > > > 000
                  > > > 001
                  > > > 010
                  > > > 011
                  > > > 100
                  > > > 101
                  > > > 110
                  > > > 111
                  > > >
                  > > >
                  > > > Metodo infallibile per avere tutte le varianti, e ho subito pensato a una matrice.
                  > > >
                  > > > Forse riesco a gestirlo con una semplice "print", ci penserò...
                  > > >
                  > > >
                  > > >
                  > > >
                  > > >
                  > >
                  > > Ma cosa vuoi fare? Ottenere le combinazioni (con ripetizione) di n elementi a k per volta - ovvero di k elementi presi in un insieme di n?
                  >
                  > la domanda corretta è: ma ti servono tutte in una volta?

                  È quello che abbiamo già detto.
                • Avatar
                  Scritto da
                  Non Autenticato
                  il 2013-02-12 17:41:28.0 alle 2013-02-12 17:41:28.0
                  Re: java merda
                  Scritto da: The Lich
                  >
                  > la domanda corretta è: ma ti servono tutte in una volta?
                  >

                  Non preoccuparti, ora ho trovato un algoritmo che messo su carta sembra funzionare e mi basta soltanto un array con una lunghezza pari a quella della stringa.
                  Spero di non avere altre sorprese sul piano tecnico. Fantasma
                  • Avatar
                    ☺
                    Scritto da
                    The Lich
                    Übermensch
                    il 2013-02-12 23:51:34.0 alle 2013-02-12 23:51:34.0
                    Trollate totali: 21351
                    Re: java merda
                    Scritto da:
                    > Scritto da: The Lich
                    > >
                    > > la domanda corretta è: ma ti servono tutte in una volta?
                    > >
                    >
                    > Non preoccuparti, ora ho trovato un algoritmo che messo su carta sembra funzionare e mi basta soltanto un array con una lunghezza pari a quella della stringa.
                    > Spero di non avere altre sorprese sul piano tecnico. Fantasma

                    io non mi preoccupo mica, visto che non me ne frega un accidente di nulla

                    The Lich™
                    « Non è morto ciò che in eterno può attendere,
                    e col passare di strani eoni, anche la morte può morire. »
                    Cylon
                    Immagine postata dall'utente
        • Avatar
          ☺
          Scritto da
          gengiva
          Utente privileggiato
          il 2013-02-10 21:13:21.0 alle 2013-02-10 21:13:21.0
          Trollate totali: 9100
          Re: java merda
          Scritto da:
          > Scritto da: gengiva
          > > Scritto da:
          > > > Ho bisogno di una matrice di queste dimensioni
          > > >
          > > > matrice[312500000][x]
          > > >
          > > > e oltre...
          > > >
          > > > Ma oltre un certo numero mi esce il seguente messaggio d'errore:
          > > >
          > > > Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
          > > > at combinazioni.Combinazioni.main
          > > >
          > > > Ovvero, lo spazio disponibile per la java virtual machine si esaurisce.
          > > >
          > > > È chiaro che nella programmazione si arriva spesso a lavorare con grandi numeri e quantità di dati consistenti; sto chiedendo troppo?
          > > >
          > > > C'è modo, comunque, di aumentare le dimensioni del heap space?
          > >
          > > cosa stai programmandoNewbie, inesperto
          >
          >
          > La matrice serve a memorizzare le n varianti di una data stringa.
          >
          > Esempio semplice: ho lo 0 e ho l'1.
          >
          > 00
          > 01
          > 10
          > 11
          >
          > Ogni riga della matrice memorizza una variante.
          >
          > Il problema è che con stringhe molto grandi viene fuori una matrice enorme.

          e se invece fai una matrice grande quanto il numero totale delle stringhe?
          in ogni spazio ci metti un oggetto che chiami "stringa", e ogni stringa ha dei campi String che contengono l'originale e tutte le sue variabili

          poi per parsare i caratteri di una stringa usi StringTokenizer
          Cercatelo con Google, ritardato! ©
          • Avatar
            Scritto da
            Non Autenticato
            il 2013-02-11 00:20:14.0 alle 2013-02-11 00:20:14.0
            Re: java merda
            Scritto da: gengiva
            > Scritto da:
            > > Scritto da: gengiva
            > > > Scritto da:
            > > > > Ho bisogno di una matrice di queste dimensioni
            > > > >
            > > > > matrice[312500000][x]
            > > > >
            > > > > e oltre...
            > > > >
            > > > > Ma oltre un certo numero mi esce il seguente messaggio d'errore:
            > > > >
            > > > > Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
            > > > > at combinazioni.Combinazioni.main
            > > > >
            > > > > Ovvero, lo spazio disponibile per la java virtual machine si esaurisce.
            > > > >
            > > > > È chiaro che nella programmazione si arriva spesso a lavorare con grandi numeri e quantità di dati consistenti; sto chiedendo troppo?
            > > > >
            > > > > C'è modo, comunque, di aumentare le dimensioni del heap space?
            > > >
            > > > cosa stai programmandoNewbie, inesperto
            > >
            > >
            > > La matrice serve a memorizzare le n varianti di una data stringa.
            > >
            > > Esempio semplice: ho lo 0 e ho l'1.
            > >
            > > 00
            > > 01
            > > 10
            > > 11
            > >
            > > Ogni riga della matrice memorizza una variante.
            > >
            > > Il problema è che con stringhe molto grandi viene fuori una matrice enorme.
            >
            > e se invece fai una matrice grande quanto il numero totale delle stringhe?
            > in ogni spazio ci metti un oggetto che chiami "stringa", e ogni stringa ha dei campi String che contengono l'originale e tutte le sue variabili
            >
            > poi per parsare i caratteri di una stringa usi StringTokenizer

            taci troia
<softv>

Pagina generata in 263 millisecondi

Utenti attivi: 15 nell'ultimo minuto, 25 negli ultimi cinque minuti, 42 negli ultimi 15 minuti