Mostra notizie nelle discussioni
  • Avatar
    ☺
    Scritto da
    il 2010-10-09 01:15:00.0 alle 2010-10-09 01:15:00.0
    Trollate totali: 1386
    @ avvelentani
    Problema intrinsecamente esponenziale un paio di palle.
    Eliminate liste dinamiche e fatto solo con array e offset, evitando di ricreare strutture e lavorando di fino (shift bitwise) sono a 1800ms peri miei 21 elementi.
    Vado a dormire soddisfatto. Ficoso
    • Avatar
      Scritto da
      Non Autenticato
      il 2010-10-09 10:12:00.0 alle 2010-10-09 10:12:00.0
      Re: @ avvelentani
      - Scritto da: Svyatopolk
      > Problema intrinsecamente esponenziale un paio di
      > palle.
      > Eliminate liste dinamiche e fatto solo con array
      > e offset, evitando di ricreare strutture e
      > lavorando di fino (shift bitwise) sono a 1800ms
      > peri miei 21
      > elementi.
      > Vado a dormire soddisfatto. Ficoso

      se con 20 impiega metà tempo è esponenziale Cylon
      • Avatar
        ☺
        Scritto da
        il 2010-10-09 11:51:00.0 alle 2010-10-09 11:51:00.0
        Trollate totali: 4459
        Re: @ avvelentani

        - Scritto da:
        > - Scritto da: Svyatopolk
        > > Problema intrinsecamente esponenziale un paio di
        > > palle.
        > > Eliminate liste dinamiche e fatto solo con array
        > > e offset, evitando di ricreare strutture e
        > > lavorando di fino (shift bitwise) sono a 1800ms
        > > peri miei 21
        > > elementi.
        > > Vado a dormire soddisfatto. Ficoso
        >
        > se con 20 impiega metà tempo è esponenziale
        > Cylon

        La differenza tra un teorico scienziato dell'informazione e un pratico ingegnere informatico. Il primo ti dice che è esponenziale, il secondo che con la roba che doveva fare ci ha messo meno di due secondi.


        GRANDISSIMO LICHPOLK Cylon
        • Avatar
          ☺
          Scritto da
          il 2010-10-09 13:11:00.0 alle 2010-10-09 13:11:00.0
          Trollate totali: 301
          Re: @ avvelentani

          - Scritto da: Caccola
          >
          > - Scritto da:
          > > - Scritto da: Svyatopolk
          > > > Problema intrinsecamente esponenziale un paio
          > di
          > > > palle.
          > > > Eliminate liste dinamiche e fatto solo con
          > array
          > > > e offset, evitando di ricreare strutture e
          > > > lavorando di fino (shift bitwise) sono a
          > 1800ms
          > > > peri miei 21
          > > > elementi.
          > > > Vado a dormire soddisfatto. Ficoso
          > >
          > > se con 20 impiega metà tempo è esponenziale
          > > Cylon
          >
          > La differenza tra un teorico scienziato
          > dell'informazione e un pratico ingegnere
          > informatico. Il primo ti dice che è esponenziale,
          > il secondo che con la roba che doveva fare ci ha
          > messo meno di due
          > secondi.
          >
          >
          > GRANDISSIMO LICHPOLK Cylon

          Questo qui ci ha offesi, dovremo sfidarlo a duello prima o poi. Triste
        • Avatar
          ☺
          Scritto da
          il 2010-10-09 14:47:00.0 alle 2010-10-09 14:47:00.0
          Trollate totali: 1386
          Re: @ avvelentani
          - Scritto da: Caccola
          >
          > - Scritto da:
          > > - Scritto da: Svyatopolk
          > > > Problema intrinsecamente esponenziale un paio
          > di
          > > > palle.
          > > > Eliminate liste dinamiche e fatto solo con
          > array
          > > > e offset, evitando di ricreare strutture e
          > > > lavorando di fino (shift bitwise) sono a
          > 1800ms
          > > > peri miei 21
          > > > elementi.
          > > > Vado a dormire soddisfatto. Ficoso
          > >
          > > se con 20 impiega metà tempo è esponenziale
          > > Cylon
          >
          > La differenza tra un teorico scienziato
          > dell'informazione e un pratico ingegnere
          > informatico. Il primo ti dice che è esponenziale,
          > il secondo che con la roba che doveva fare ci ha
          > messo meno di due
          > secondi.
          >
          >
          > GRANDISSIMO LICHPOLK Cylon

          Era una risposta a questo:
          01:04 <@sarru> suoranciata passera` la notte a lottare contro un algoritmo esponenziale

          Era il terzo quesito del greplin programming challenge, niente di trascendentale insomma.
          E i numeri erano 22, ma a quell'ora comincio a sfarfallare Imbarazzato

          http://challenge.greplin.com/
          • Avatar
            ☺
            Scritto da
            il 2010-10-09 16:09:00.0 alle 2010-10-09 16:09:00.0
            Trollate totali: 4459
            Re: @ avvelentani

            - Scritto da: Svyatopolk
            > - Scritto da: Caccola
            > >
            > > - Scritto da:
            > > > - Scritto da: Svyatopolk
            > > > > Problema intrinsecamente esponenziale un
            > paio
            > > di
            > > > > palle.
            > > > > Eliminate liste dinamiche e fatto solo con
            > > array
            > > > > e offset, evitando di ricreare strutture e
            > > > > lavorando di fino (shift bitwise) sono a
            > > 1800ms
            > > > > peri miei 21
            > > > > elementi.
            > > > > Vado a dormire soddisfatto. Ficoso
            > > >
            > > > se con 20 impiega metà tempo è esponenziale
            > > > Cylon
            > >
            > > La differenza tra un teorico scienziato
            > > dell'informazione e un pratico ingegnere
            > > informatico. Il primo ti dice che è
            > esponenziale,
            > > il secondo che con la roba che doveva fare ci ha
            > > messo meno di due
            > > secondi.
            > >
            > >
            > > GRANDISSIMO LICHPOLK Cylon
            >
            > Era una risposta a questo:
            > 01:04 <@sarru> suoranciata passera` la notte a
            > lottare contro un algoritmo
            > esponenziale
            >
            > Era il terzo quesito del greplin programming
            > challenge, niente di trascendentale
            > insomma.
            > E i numeri erano 22, ma a quell'ora comincio a
            > sfarfallare
            > Imbarazzato
            >
            > http://challenge.greplin.com/

            fico! Sorpresa
    • Avatar
      ☺
      Scritto da
      avvelentani
      Cubicolario
      il 2010-10-09 15:28:00.0 alle 2010-10-09 15:28:00.0
      Trollate totali: 18184
      Re: @ avvelentani

      - Scritto da: Svyatopolk
      > Problema intrinsecamente esponenziale un paio di
      > palle.
      > Eliminate liste dinamiche e fatto solo con array
      > e offset, evitando di ricreare strutture e
      > lavorando di fino (shift bitwise) sono a 1800ms
      > peri miei 21
      > elementi.
      > Vado a dormire soddisfatto. Ficoso

      Buon per te, la mia soluzione scrausa scritta in 10 minuti per spolverare il python ci mette 45 secondi:

      def subsets(aset, n):
          if len(aset) < n: return []
          if n == 0: return [set()]
          r = []
          remaining_set = set(aset)
          for element in aset:
              remaining_set.remove(element)
              for subset in subsets(remaining_set, n-1):
                  subset.add(element)
                  r.append(subset)
          return r
      
      import sys
      if __name__ == '__main__':
          size = int(sys.argv[1])+1
          r = []
          for n in range (0, size):
              r.append(subsets(set(range(1, size)), n))
      


      (25 se non costruisco la lista finale)

      ora io posso dire di non aver perso tempo a micro ottimizzare un problema giocattolo intrinsecamente esponenziale, tu no Ficoso
      I think happiness is love
      - Vladimir Putin
      • Avatar
        ☺
        Scritto da
        il 2010-10-09 15:55:00.0 alle 2010-10-09 15:55:00.0
        Trollate totali: 1386
        Re: @ avvelentani
        - Scritto da: avvelentani
        >
        > - Scritto da: Svyatopolk
        > > Problema intrinsecamente esponenziale un paio di
        > > palle.
        > > Eliminate liste dinamiche e fatto solo con array
        > > e offset, evitando di ricreare strutture e
        > > lavorando di fino (shift bitwise) sono a 1800ms
        > > peri miei 21
        > > elementi.
        > > Vado a dormire soddisfatto. Ficoso
        >
        > Buon per te, la mia soluzione scrausa scritta in
        > 10 minuti per spolverare il python ci mette 45
        > secondi:
        >
        >
        > def subsets(aset, n):
        >     if len(aset) < n: return []
        >     if n == 0: return [set()]
        >     r = []
        >     remaining_set = set(aset)
        >     for element in aset:
        >         remaining_set.remove(element)
        >         for subset in subsets(remaining_set, n-1):
        >             subset.add(element)
        >             r.append(subset)
        >     return r
        > 
        > import sys
        > if __name__ == '__main__':
        >     size = int(sys.argv[1])+1
        >     r = []
        >     for n in range (0, size):
        >         r.append(subsets(set(range(1, size)), n))
        > 

        >
        > (25 se non costruisco la lista finale)
        >
        > ora io posso dire di non aver perso tempo a micro
        > ottimizzare un problema giocattolo
        > intrinsecamente esponenziale, tu no
        > Ficoso
        Triste


















































































        Però è più veloce il mio 1 - 1 Ficoso
        • Avatar
          ☺
          Scritto da
          il 2010-10-09 16:11:00.0 alle 2010-10-09 16:11:00.0
          Trollate totali: 4459
          Re: @ avvelentani

          - Scritto da: Svyatopolk
          > - Scritto da: avvelentani
          > >
          > > - Scritto da: Svyatopolk
          > > > Problema intrinsecamente esponenziale un paio
          > di
          > > > palle.
          > > > Eliminate liste dinamiche e fatto solo con
          > array
          > > > e offset, evitando di ricreare strutture e
          > > > lavorando di fino (shift bitwise) sono a
          > 1800ms
          > > > peri miei 21
          > > > elementi.
          > > > Vado a dormire soddisfatto. Ficoso
          > >
          > > Buon per te, la mia soluzione scrausa scritta in
          > > 10 minuti per spolverare il python ci mette 45
          > > secondi:
          > >
          > >
          > > def subsets(aset, n):
          > >     if len(aset) < n: return []
          > >     if n == 0: return [set()]
          > >     r = []
          > >     remaining_set = set(aset)
          > >     for element in aset:
          > >         remaining_set.remove(element)
          > >         for subset in subsets(remaining_set,
          > n-1):
          > >             subset.add(element)
          > >             r.append(subset)
          > >     return r
          > > 
          > > import sys
          > > if __name__ == '__main__':
          > >     size = int(sys.argv[1])+1
          > >     r = []
          > >     for n in range (0, size):
          > >         r.append(subsets(set(range(1, size)),
          > n))
          > > 

          > >
          > > (25 se non costruisco la lista finale)
          > >
          > > ora io posso dire di non aver perso tempo a
          > micro
          > > ottimizzare un problema giocattolo
          > > intrinsecamente esponenziale, tu no
          > > Ficoso
          > Triste
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          >
          > Però è più veloce il mio 1 - 1 Ficoso

          Non ho voglia e tempo di mettermi adesso a risolvere i quesiti (posto che riesca a farne qualcuno tra l'altro), in cosa consisteva il 3° quesito?
          • Avatar
            ☺
            Scritto da
            il 2010-10-09 16:15:00.0 alle 2010-10-09 16:15:00.0
            Trollate totali: 1386
            Re: @ avvelentani
            - Scritto da: Caccola
            >
            > - Scritto da: Svyatopolk
            > > - Scritto da: avvelentani
            > > >
            > > > - Scritto da: Svyatopolk
            > > > > Problema intrinsecamente esponenziale un
            > paio
            > > di
            > > > > palle.
            > > > > Eliminate liste dinamiche e fatto solo con
            > > array
            > > > > e offset, evitando di ricreare strutture e
            > > > > lavorando di fino (shift bitwise) sono a
            > > 1800ms
            > > > > peri miei 21
            > > > > elementi.
            > > > > Vado a dormire soddisfatto. Ficoso
            > > >
            > > > Buon per te, la mia soluzione scrausa scritta
            > in
            > > > 10 minuti per spolverare il python ci mette 45
            > > > secondi:
            > > >
            > > >
            > > > def subsets(aset, n):
            > > >     if len(aset) < n: return []
            > > >     if n == 0: return [set()]
            > > >     r = []
            > > >     remaining_set = set(aset)
            > > >     for element in aset:
            > > >         remaining_set.remove(element)
            > > >         for subset in subsets(remaining_set,
            > > n-1):
            > > >             subset.add(element)
            > > >             r.append(subset)
            > > >     return r
            > > > 
            > > > import sys
            > > > if __name__ == '__main__':
            > > >     size = int(sys.argv[1])+1
            > > >     r = []
            > > >     for n in range (0, size):
            > > >         r.append(subsets(set(range(1, size)),
            > > n))
            > > > 

            > > >
            > > > (25 se non costruisco la lista finale)
            > > >
            > > > ora io posso dire di non aver perso tempo a
            > > micro
            > > > ottimizzare un problema giocattolo
            > > > intrinsecamente esponenziale, tu no
            > > > Ficoso
            > > Triste
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > >
            > > Però è più veloce il mio 1 - 1 Ficoso
            >
            > Non ho voglia e tempo di mettermi adesso a
            > risolvere i quesiti (posto che riesca a farne
            > qualcuno tra l'altro), in cosa consisteva il 3°
            > quesito?


            Ho risvegliato gli istinti del sassofono, adesso millanta soluzioni da 50ms(però ancora non me l'ha mostrata). Triste

            Il quesito era questo:

            For the final task, you must find all subsets of an array
                where the largest number is the sum of the remaining numbers.
                For example, for an input of:

                (1, 2, 3, 4, 6)

                the subsets would be

                1 + 2 = 3
                1 + 3 = 4
                2 + 4 = 6
                1 + 2 + 3 = 6
                
                Here is the list of numbers you should run your code on.
                The password is the number of subsets. In the above case the
                answer would be 4.

            input: 3, 4, 9, 14, 15, 19, 28, 37, 47, 50, 54,
                                 56, 59, 61, 70, 73, 78, 81, 92, 95, 97, 99


            La risposta giusta è 179.
        • Avatar
          ☺
          Scritto da
          avvelentani
          Cubicolario
          il 2010-10-09 16:19:00.0 alle 2010-10-09 16:19:00.0
          Trollate totali: 18184
          Re: @ avvelentani
          Allora questa e` la storia:

          ieri sera suoranciata mi chiede aiuto ***disperato*** in chat:

          23:13 @suoranciata sarru: dammi una mano
          23:13 @suoranciata dato un array di interi
          23:13 @suoranciata metti 1,2,3,4,5
          23:13 @suoranciata come faccio a trovare tutti i possibili subsets
          23:14 @sarru con una enumerazione esaustiva ricorsiva
          23:14 @sarru per esempio
          23:14 @suoranciata anche con "i buchi" eh
          23:14 @suoranciata 1,2,4 è un subsets per come mi serve
          23:14 @sarru si`
          23:15 @suoranciata ah prendo 1, e lo accoppio ai subset di 2-5
          23:15 @suoranciata non mi è chiaro
          23:16 @sarru diciamo che subsets(inputset, n) e` l'insieme vuoto se n == 0 oppure per ogni elemento x in inputset devi restituire tutti i subset restituiti da subsets(inputset\{x}, n-1) con l'elemento x attaccato
          23:16 @sarru quello che vuoi te e` l'unione di tutti i subsets(inputset, n) con n = 0 .. len(inputset)
          23:17 @suoranciata mumble
          23:17 @sarru come mai lo vuoi sapere?
          23:17 @suoranciata non mi è chiaro come implementarlo
          23:18 @suoranciata giocavo a greplin programming challenge, è l'ultima domanda
          ...
          00:37 @suoranciata ho un input di 21 numeri, non posso credere che la soluzione necessiti di così tanto
          00:38 @suoranciata in genere i giochini di project euler se ci mettevi più di 4-5 secondi eri sulla strada sbagliata
          00:38 @suoranciata questo immagino sia simile
          00:40 @suoranciata il numero di subset + l'array stesso è pari a 2^n - 1
          00:40 @suoranciata prevedendo le dimensioni forse ne ricavo qualcosa
          00:59 @sarru suoranciata passera` la notte a lottare contro un algoritmo esponenziale
          01:00 @suoranciata ho buone probabilità di vincere
          01:00 @sarru lol
          01:00 @sarru certo
          --- Log closed Fri Oct 08 00:11:44 2010
          


          Quindi la soluzione gliel'ho data io e poi lui viene anche a vantarsi di essere un genio. Oggi mi ha spiegato meglio qual'e` il problema. Sapendo qual'e` il problema vero e` possibile implementare una soluzione molto piu` veloce, senza bisogno di seghe mentali con vettori e shift bitwise:

          input_vector = [3, 4, 9, 14, 15, 19, 28, 37, 47, 50, 54, 56, 59, 61, 70, 73, 78, 81, 92, 95, 97, 99]
          
          maximum = max(input_vector)
          
          result = 0
          
          def suoranciata(sum, start):
              print "called with sum:", sum
              if sum > maximum: return
              for i in range(start, len(input_vector)):
                  if input_vector[i] == sum:
                      print "incrementing result ", selection, " + ", input_vector[i]
                      global result
                      result += 1
                  print "selected:", input_vector[i]
                  suoranciata(sum + input_vector[i], i+1)
              print "returning"
          
          suoranciata(0, 0)
          print len(input_vector), result
          


          tempo di completamento: 50 millisecondi.
          I think happiness is love
          - Vladimir Putin
          • Avatar
            ☺
            Scritto da
            il 2010-10-09 16:22:00.0 alle 2010-10-09 16:22:00.0
            Trollate totali: 1386
            Re: @ avvelentani
            - Scritto da: avvelentani
            > Allora questa e` la storia:
            >
            > ieri sera suoranciata mi chiede aiuto
            > ***disperato*** in
            > chat:
            >
            >
            > 23:13 @suoranciata sarru: dammi una mano
            > 23:13 @suoranciata dato un array di interi
            > 23:13 @suoranciata metti 1,2,3,4,5
            > 23:13 @suoranciata come faccio a trovare tutti i
            > possibili
            > subsets
            > 23:14 @sarru con una enumerazione esaustiva
            > ricorsiva
            > 23:14 @sarru per esempio
            > 23:14 @suoranciata anche con "i buchi" eh
            > 23:14 @suoranciata 1,2,4 è un subsets per come mi
            > serve
            > 23:14 @sarru si`
            > 23:15 @suoranciata ah prendo 1, e lo accoppio ai
            > subset di
            > 2-5
            > 23:15 @suoranciata non mi è chiaro
            > 23:16 @sarru diciamo che subsets(inputset, n) e`
            > l'insieme vuoto se n == 0 oppure per ogni
            > elemento x in inputset devi restituire tutti i
            > subset restituiti da subsets(inputset\{x}, n-1)
            > con l'elemento x
            > attaccato
            > 23:16 @sarru quello che vuoi te e` l'unione di
            > tutti i subsets(inputset, n) con n = 0 ..
            > len(inputset)
            > 23:17 @suoranciata mumble
            > 23:17 @sarru come mai lo vuoi sapere?
            > 23:17 @suoranciata non mi è chiaro come
            > implementarlo
            > 23:18 @suoranciata giocavo a greplin programming
            > challenge, è l'ultima
            > domanda
            > ...
            > 00:37 @suoranciata ho un input di 21 numeri, non
            > posso credere che la soluzione necessiti di così
            > tanto
            > 00:38 @suoranciata in genere i giochini di
            > project euler se ci mettevi più di 4-5 secondi
            > eri sulla strada
            > sbagliata
            > 00:38 @suoranciata questo immagino sia simile
            > 00:40 @suoranciata il numero di subset + l'array
            > stesso è pari a 2^n -
            > 1
            > 00:40 @suoranciata prevedendo le dimensioni forse
            > ne ricavo
            > qualcosa
            > 00:59 @sarru suoranciata passera` la notte a
            > lottare contro un algoritmo
            > esponenziale
            > 01:00 @suoranciata ho buone probabilità di vincere
            > 01:00 @sarru lol
            > 01:00 @sarru certo
            > --- Log closed Fri Oct 08 00:11:44 2010
            > 

            >
            > Quindi la soluzione gliel'ho data io e poi lui
            > viene anche a vantarsi di essere un genio. Oggi
            > mi ha spiegato meglio qual'e` il problema.
            > Sapendo qual'e` il problema vero e` possibile
            > implementare una soluzione molto piu` veloce,
            > senza bisogno di seghe mentali con vettori e
            > shift
            > bitwise:
            >
            >
            > input_vector = [3, 4, 9, 14, 15, 19, 28, 37, 47,
            > 50, 54, 56, 59, 61, 70, 73, 78, 81, 92, 95, 97,
            > 99]
            > 
            > maximum = max(input_vector)
            > 
            > result = 0
            > 
            > def suoranciata(sum, start):
            >     print "called with sum:", sum
            >     if sum > maximum: return
            >     for i in range(start, len(input_vector)):
            >         if input_vector[i] == sum:
            >             print "incrementing result ",
            > selection, " + ",
            > input_vector[i]
            >             global result
            >             result += 1
            >         print "selected:", input_vector[i]
            >         suoranciata(sum + input_vector[i], i+1)
            >     print "returning"
            > 
            > suoranciata(0, 0)
            > print len(input_vector), result
            > 

            >
            > tempo di completamento: 50 millisecondi.



            Ci hai messo 50 minuti solo per dimostrare che la tua soluzione è migliore della mia? Sorpresa
            • Avatar
              ☺
              Scritto da
              avvelentani
              Cubicolario
              il 2010-10-09 16:28:00.0 alle 2010-10-09 16:28:00.0
              Trollate totali: 18184
              Re: @ avvelentani

              - Scritto da: Svyatopolk
              > - Scritto da: avvelentani
              > > Allora questa e` la storia:
              > >
              > > ieri sera suoranciata mi chiede aiuto
              > > ***disperato*** in
              > > chat:
              > >
              > >
              > > 23:13 @suoranciata sarru: dammi una mano
              > > 23:13 @suoranciata dato un array di interi
              > > 23:13 @suoranciata metti 1,2,3,4,5
              > > 23:13 @suoranciata come faccio a trovare tutti i
              > > possibili
              > > subsets
              > > 23:14 @sarru con una enumerazione esaustiva
              > > ricorsiva
              > > 23:14 @sarru per esempio
              > > 23:14 @suoranciata anche con "i buchi" eh
              > > 23:14 @suoranciata 1,2,4 è un subsets per come
              > mi
              > > serve
              > > 23:14 @sarru si`
              > > 23:15 @suoranciata ah prendo 1, e lo accoppio ai
              > > subset di
              > > 2-5
              > > 23:15 @suoranciata non mi è chiaro
              > > 23:16 @sarru diciamo che subsets(inputset, n) e`
              > > l'insieme vuoto se n == 0 oppure per ogni
              > > elemento x in inputset devi restituire tutti i
              > > subset restituiti da subsets(inputset\{x}, n-1)
              > > con l'elemento x
              > > attaccato
              > > 23:16 @sarru quello che vuoi te e` l'unione di
              > > tutti i subsets(inputset, n) con n = 0 ..
              > > len(inputset)
              > > 23:17 @suoranciata mumble
              > > 23:17 @sarru come mai lo vuoi sapere?
              > > 23:17 @suoranciata non mi è chiaro come
              > > implementarlo
              > > 23:18 @suoranciata giocavo a greplin programming
              > > challenge, è l'ultima
              > > domanda
              > > ...
              > > 00:37 @suoranciata ho un input di 21 numeri, non
              > > posso credere che la soluzione necessiti di così
              > > tanto
              > > 00:38 @suoranciata in genere i giochini di
              > > project euler se ci mettevi più di 4-5 secondi
              > > eri sulla strada
              > > sbagliata
              > > 00:38 @suoranciata questo immagino sia simile
              > > 00:40 @suoranciata il numero di subset + l'array
              > > stesso è pari a 2^n -
              > > 1
              > > 00:40 @suoranciata prevedendo le dimensioni
              > forse
              > > ne ricavo
              > > qualcosa
              > > 00:59 @sarru suoranciata passera` la notte a
              > > lottare contro un algoritmo
              > > esponenziale
              > > 01:00 @suoranciata ho buone probabilità di
              > vincere
              > > 01:00 @sarru lol
              > > 01:00 @sarru certo
              > > --- Log closed Fri Oct 08 00:11:44 2010
              > > 

              > >
              > > Quindi la soluzione gliel'ho data io e poi lui
              > > viene anche a vantarsi di essere un genio. Oggi
              > > mi ha spiegato meglio qual'e` il problema.
              > > Sapendo qual'e` il problema vero e` possibile
              > > implementare una soluzione molto piu` veloce,
              > > senza bisogno di seghe mentali con vettori e
              > > shift
              > > bitwise:
              > >
              > >
              > > input_vector = [3, 4, 9, 14, 15, 19, 28, 37, 47,
              > > 50, 54, 56, 59, 61, 70, 73, 78, 81, 92, 95, 97,
              > > 99]
              > > 
              > > maximum = max(input_vector)
              > > 
              > > result = 0
              > > 
              > > def suoranciata(sum, start):
              > >     print "called with sum:", sum
              > >     if sum > maximum: return
              > >     for i in range(start, len(input_vector)):
              > >         if input_vector[i] == sum:
              > >             print "incrementing result ",
              > > selection, " + ",
              > > input_vector[i]
              > >             global result
              > >             result += 1
              > >         print "selected:", input_vector[i]
              > >         suoranciata(sum + input_vector[i], i+1)
              > >     print "returning"
              > > 
              > > suoranciata(0, 0)
              > > print len(input_vector), result
              > > 

              > >
              > > tempo di completamento: 50 millisecondi.
              >
              >
              >
              > Ci hai messo 50 minuti solo per dimostrare che la
              > tua soluzione è migliore della mia?
              > Sorpresa

              ROSIK Ficoso
              I think happiness is love
              - Vladimir Putin
              • Avatar
                ☺
                Scritto da
                il 2010-10-09 16:34:00.0 alle 2010-10-09 16:34:00.0
                Trollate totali: 60
                Re: @ avvelentani

                - Scritto da: avvelentani
                >
                > - Scritto da: Svyatopolk
                > > - Scritto da: avvelentani
                > > > Allora questa e` la storia:
                > > >
                > > > ieri sera suoranciata mi chiede aiuto
                > > > ***disperato*** in
                > > > chat:
                > > >
                > > >
                > > > 23:13 @suoranciata sarru: dammi una mano
                > > > 23:13 @suoranciata dato un array di interi
                > > > 23:13 @suoranciata metti 1,2,3,4,5
                > > > 23:13 @suoranciata come faccio a trovare
                > tutti
                > i
                > > > possibili
                > > > subsets
                > > > 23:14 @sarru con una enumerazione esaustiva
                > > > ricorsiva
                > > > 23:14 @sarru per esempio
                > > > 23:14 @suoranciata anche con "i buchi" eh
                > > > 23:14 @suoranciata 1,2,4 è un subsets per come
                > > mi
                > > > serve
                > > > 23:14 @sarru si`
                > > > 23:15 @suoranciata ah prendo 1, e lo accoppio
                > ai
                > > > subset di
                > > > 2-5
                > > > 23:15 @suoranciata non mi è chiaro
                > > > 23:16 @sarru diciamo che subsets(inputset, n)
                > e`
                > > > l'insieme vuoto se n == 0 oppure per ogni
                > > > elemento x in inputset devi restituire tutti i
                > > > subset restituiti da subsets(inputset\{x},
                > n-1)
                > > > con l'elemento x
                > > > attaccato
                > > > 23:16 @sarru quello che vuoi te e` l'unione di
                > > > tutti i subsets(inputset, n) con n = 0 ..
                > > > len(inputset)
                > > > 23:17 @suoranciata mumble
                > > > 23:17 @sarru come mai lo vuoi sapere?
                > > > 23:17 @suoranciata non mi è chiaro come
                > > > implementarlo
                > > > 23:18 @suoranciata giocavo a greplin
                > programming
                > > > challenge, è l'ultima
                > > > domanda
                > > > ...
                > > > 00:37 @suoranciata ho un input di 21 numeri,
                > non
                > > > posso credere che la soluzione necessiti di
                > così
                > > > tanto
                > > > 00:38 @suoranciata in genere i giochini di
                > > > project euler se ci mettevi più di 4-5 secondi
                > > > eri sulla strada
                > > > sbagliata
                > > > 00:38 @suoranciata questo immagino sia simile
                > > > 00:40 @suoranciata il numero di subset +
                > l'array
                > > > stesso è pari a 2^n -
                > > > 1
                > > > 00:40 @suoranciata prevedendo le dimensioni
                > > forse
                > > > ne ricavo
                > > > qualcosa
                > > > 00:59 @sarru suoranciata passera` la notte a
                > > > lottare contro un algoritmo
                > > > esponenziale
                > > > 01:00 @suoranciata ho buone probabilità di
                > > vincere
                > > > 01:00 @sarru lol
                > > > 01:00 @sarru certo
                > > > --- Log closed Fri Oct 08 00:11:44 2010
                > > > 

                > > >
                > > > Quindi la soluzione gliel'ho data io e poi lui
                > > > viene anche a vantarsi di essere un genio.
                > Oggi
                > > > mi ha spiegato meglio qual'e` il problema.
                > > > Sapendo qual'e` il problema vero e` possibile
                > > > implementare una soluzione molto piu` veloce,
                > > > senza bisogno di seghe mentali con vettori e
                > > > shift
                > > > bitwise:
                > > >
                > > >
                > > > input_vector = [3, 4, 9, 14, 15, 19, 28, 37,
                > 47,
                > > > 50, 54, 56, 59, 61, 70, 73, 78, 81, 92, 95,
                > 97,
                > > > 99]
                > > > 
                > > > maximum = max(input_vector)
                > > > 
                > > > result = 0
                > > > 
                > > > def suoranciata(sum, start):
                > > >     print "called with sum:", sum
                > > >     if sum > maximum: return
                > > >     for i in range(start, len(input_vector)):
                > > >         if input_vector[i] == sum:
                > > >             print "incrementing result ",
                > > > selection, " + ",
                > > > input_vector[i]
                > > >             global result
                > > >             result += 1
                > > >         print "selected:", input_vector[i]
                > > >         suoranciata(sum + input_vector[i],
                > i+1)
                > > >     print "returning"
                > > > 
                > > > suoranciata(0, 0)
                > > > print len(input_vector), result
                > > > 

                > > >
                > > > tempo di completamento: 50 millisecondi.
                > >
                > >
                > >
                > > Ci hai messo 50 minuti solo per dimostrare che
                > la
                > > tua soluzione è migliore della mia?
                > > Sorpresa
                >
                > ROSIK Ficoso

                Quoto Ficoso
          • Avatar
            ☺
            Scritto da
            il 2010-10-09 16:39:00.0 alle 2010-10-09 16:39:00.0
            Trollate totali: 4459
            Re: @ avvelentani

            - Scritto da: avvelentani
            > Allora questa e` la storia:
            >
            > ieri sera suoranciata mi chiede aiuto
            > ***disperato*** in
            > chat:
            >
            >
            > 23:13 @suoranciata sarru: dammi una mano
            > 23:13 @suoranciata dato un array di interi
            > 23:13 @suoranciata metti 1,2,3,4,5
            > 23:13 @suoranciata come faccio a trovare tutti i
            > possibili
            > subsets
            > 23:14 @sarru con una enumerazione esaustiva
            > ricorsiva
            > 23:14 @sarru per esempio
            > 23:14 @suoranciata anche con "i buchi" eh
            > 23:14 @suoranciata 1,2,4 è un subsets per come mi
            > serve
            > 23:14 @sarru si`
            > 23:15 @suoranciata ah prendo 1, e lo accoppio ai
            > subset di
            > 2-5
            > 23:15 @suoranciata non mi è chiaro
            > 23:16 @sarru diciamo che subsets(inputset, n) e`
            > l'insieme vuoto se n == 0 oppure per ogni
            > elemento x in inputset devi restituire tutti i
            > subset restituiti da subsets(inputset\{x}, n-1)
            > con l'elemento x
            > attaccato
            > 23:16 @sarru quello che vuoi te e` l'unione di
            > tutti i subsets(inputset, n) con n = 0 ..
            > len(inputset)
            > 23:17 @suoranciata mumble
            > 23:17 @sarru come mai lo vuoi sapere?
            > 23:17 @suoranciata non mi è chiaro come
            > implementarlo
            > 23:18 @suoranciata giocavo a greplin programming
            > challenge, è l'ultima
            > domanda
            > ...
            > 00:37 @suoranciata ho un input di 21 numeri, non
            > posso credere che la soluzione necessiti di così
            > tanto
            > 00:38 @suoranciata in genere i giochini di
            > project euler se ci mettevi più di 4-5 secondi
            > eri sulla strada
            > sbagliata
            > 00:38 @suoranciata questo immagino sia simile
            > 00:40 @suoranciata il numero di subset + l'array
            > stesso è pari a 2^n -
            > 1
            > 00:40 @suoranciata prevedendo le dimensioni forse
            > ne ricavo
            > qualcosa
            > 00:59 @sarru suoranciata passera` la notte a
            > lottare contro un algoritmo
            > esponenziale
            > 01:00 @suoranciata ho buone probabilità di vincere
            > 01:00 @sarru lol
            > 01:00 @sarru certo
            > --- Log closed Fri Oct 08 00:11:44 2010
            > 

            >
            > Quindi la soluzione gliel'ho data io e poi lui
            > viene anche a vantarsi di essere un genio. Oggi
            > mi ha spiegato meglio qual'e` il problema.
            > Sapendo qual'e` il problema vero e` possibile
            > implementare una soluzione molto piu` veloce,
            > senza bisogno di seghe mentali con vettori e
            > shift
            > bitwise:
            >
            >
            > input_vector = [3, 4, 9, 14, 15, 19, 28, 37, 47,
            > 50, 54, 56, 59, 61, 70, 73, 78, 81, 92, 95, 97,
            > 99]
            > 
            > maximum = max(input_vector)
            > 
            > result = 0
            > 
            > def suoranciata(sum, start):
            >     print "called with sum:", sum
            >     if sum > maximum: return
            >     for i in range(start, len(input_vector)):
            >         if input_vector[i] == sum:
            >             print "incrementing result ",
            > selection, " + ",
            > input_vector[i]
            >             global result
            >             result += 1
            >         print "selected:", input_vector[i]
            >         suoranciata(sum + input_vector[i], i+1)
            >     print "returning"
            > 
            > suoranciata(0, 0)
            > print len(input_vector), result
            > 

            >
            > tempo di completamento: 50 millisecondi.

            Sarru ma il lisp che fine ha fatto? L'hai sacrificato per idolatrare il vitello d'oro?
            • Avatar
              ☺
              Scritto da
              avvelentani
              Cubicolario
              il 2010-10-09 17:28:00.0 alle 2010-10-09 17:28:00.0
              Trollate totali: 18184
              Re: @ avvelentani

              - Scritto da: Caccola
              >
              > - Scritto da: avvelentani
              > > Allora questa e` la storia:
              > >
              > > ieri sera suoranciata mi chiede aiuto
              > > ***disperato*** in
              > > chat:
              > >
              > >
              > > 23:13 @suoranciata sarru: dammi una mano
              > > 23:13 @suoranciata dato un array di interi
              > > 23:13 @suoranciata metti 1,2,3,4,5
              > > 23:13 @suoranciata come faccio a trovare tutti i
              > > possibili
              > > subsets
              > > 23:14 @sarru con una enumerazione esaustiva
              > > ricorsiva
              > > 23:14 @sarru per esempio
              > > 23:14 @suoranciata anche con "i buchi" eh
              > > 23:14 @suoranciata 1,2,4 è un subsets per come
              > mi
              > > serve
              > > 23:14 @sarru si`
              > > 23:15 @suoranciata ah prendo 1, e lo accoppio ai
              > > subset di
              > > 2-5
              > > 23:15 @suoranciata non mi è chiaro
              > > 23:16 @sarru diciamo che subsets(inputset, n) e`
              > > l'insieme vuoto se n == 0 oppure per ogni
              > > elemento x in inputset devi restituire tutti i
              > > subset restituiti da subsets(inputset\{x}, n-1)
              > > con l'elemento x
              > > attaccato
              > > 23:16 @sarru quello che vuoi te e` l'unione di
              > > tutti i subsets(inputset, n) con n = 0 ..
              > > len(inputset)
              > > 23:17 @suoranciata mumble
              > > 23:17 @sarru come mai lo vuoi sapere?
              > > 23:17 @suoranciata non mi è chiaro come
              > > implementarlo
              > > 23:18 @suoranciata giocavo a greplin programming
              > > challenge, è l'ultima
              > > domanda
              > > ...
              > > 00:37 @suoranciata ho un input di 21 numeri, non
              > > posso credere che la soluzione necessiti di così
              > > tanto
              > > 00:38 @suoranciata in genere i giochini di
              > > project euler se ci mettevi più di 4-5 secondi
              > > eri sulla strada
              > > sbagliata
              > > 00:38 @suoranciata questo immagino sia simile
              > > 00:40 @suoranciata il numero di subset + l'array
              > > stesso è pari a 2^n -
              > > 1
              > > 00:40 @suoranciata prevedendo le dimensioni
              > forse
              > > ne ricavo
              > > qualcosa
              > > 00:59 @sarru suoranciata passera` la notte a
              > > lottare contro un algoritmo
              > > esponenziale
              > > 01:00 @suoranciata ho buone probabilità di
              > vincere
              > > 01:00 @sarru lol
              > > 01:00 @sarru certo
              > > --- Log closed Fri Oct 08 00:11:44 2010
              > > 

              > >
              > > Quindi la soluzione gliel'ho data io e poi lui
              > > viene anche a vantarsi di essere un genio. Oggi
              > > mi ha spiegato meglio qual'e` il problema.
              > > Sapendo qual'e` il problema vero e` possibile
              > > implementare una soluzione molto piu` veloce,
              > > senza bisogno di seghe mentali con vettori e
              > > shift
              > > bitwise:
              > >
              > >
              > > input_vector = [3, 4, 9, 14, 15, 19, 28, 37, 47,
              > > 50, 54, 56, 59, 61, 70, 73, 78, 81, 92, 95, 97,
              > > 99]
              > > 
              > > maximum = max(input_vector)
              > > 
              > > result = 0
              > > 
              > > def suoranciata(sum, start):
              > >     print "called with sum:", sum
              > >     if sum > maximum: return
              > >     for i in range(start, len(input_vector)):
              > >         if input_vector[i] == sum:
              > >             print "incrementing result ",
              > > selection, " + ",
              > > input_vector[i]
              > >             global result
              > >             result += 1
              > >         print "selected:", input_vector[i]
              > >         suoranciata(sum + input_vector[i], i+1)
              > >     print "returning"
              > > 
              > > suoranciata(0, 0)
              > > print len(input_vector), result
              > > 

              > >
              > > tempo di completamento: 50 millisecondi.
              >
              > Sarru ma il lisp che fine ha fatto? L'hai
              > sacrificato per idolatrare il vitello
              > d'oro?

              Quello l'ho fatto tanto tempo fa, ma e` in python per venire in contro alle vostre ridotte capacita` mentali.
              I think happiness is love
              - Vladimir Putin
    • Avatar
      Scritto da
      Non Autenticato
      il 2010-10-09 16:30:00.0 alle 2010-10-09 16:30:00.0
      Re: @ avvelentani

      - Scritto da: Svyatopolk
      > Problema intrinsecamente esponenziale un paio di
      > palle.
      > Eliminate liste dinamiche e fatto solo con array
      > e offset, evitando di ricreare strutture e
      > lavorando di fino (shift bitwise) sono a 1800ms
      > peri miei 21
      > elementi.
      > Vado a dormire soddisfatto. Ficoso

      Cazzo un venerdì notte indimenticabile Rotola dal ridere
      • Avatar
        ☺
        Scritto da
        il 2010-10-09 16:33:00.0 alle 2010-10-09 16:33:00.0
        Trollate totali: 1386
        Re: @ avvelentani
        - Scritto da:
        >
        > - Scritto da: Svyatopolk
        > > Problema intrinsecamente esponenziale un paio di
        > > palle.
        > > Eliminate liste dinamiche e fatto solo con array
        > > e offset, evitando di ricreare strutture e
        > > lavorando di fino (shift bitwise) sono a 1800ms
        > > peri miei 21
        > > elementi.
        > > Vado a dormire soddisfatto. Ficoso
        >
        > Cazzo un venerdì notte indimenticabile Rotola dal ridere

        Visti gli strascichi direi di si Con la lingua fuori
<softv>

Pagina generata in 200 millisecondi

Utenti attivi: 10 nell'ultimo minuto, 43 negli ultimi cinque minuti, 80 negli ultimi 15 minuti