-
@ avvelentaniProblema 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.
-
Re: @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@Scritto daNon Autenticatoil 2010-10-09 03:04:00.0 alle 2010-10-09 03:04:00.0§§§§§§§§§§§§§§§§§§§§§§§§§§
§§§§§§§§§§§§§§§§§§§§§§§§§§
§§§§§§§§§§§§§§§§§§§§§§§§§§
§§§§§§§§§§§§§§§§§§§§§§§§§§
§§§§§§§§§§§§§§§§§§§§§§§§§§
§§§§§§§§§§§§§§§§§§§§§§§§§§-
Re: @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@Scritto daAlessandrox(XYZ)Trollil 2010-10-09 09:35:00.0 alle 2010-10-09 09:35:00.0Trollate totali: 11553
- Scritto da:
> §§§§§§§§§§§§§§§§§§§§§§§§§§
> §§§§§§§§§§§§§§§§§§§§§§§§§§
> §§§§§§§§§§§§§§§§§§§§§§§§§§
> §§§§§§§§§§§§§§§§§§§§§§§§§§
> §§§§§§§§§§§§§§§§§§§§§§§§§§
> §§§§§§§§§§§§§§§§§§§§§§§§§§
Dev' e§§ere la §ola parte di li§ca dei di§cor§i di VendolaMa smettila di secernere cazzate!
-
-
Re: @ avvelentaniScritto daNon Autenticatoil 2010-10-09 10:12:00.0 alle 2010-10-09 10:12:00.0- 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.
se con 20 impiega metà tempo è esponenziale
-
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.
>
> se con 20 impiega metà tempo è esponenziale
>
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
-
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.
> >
> > se con 20 impiega metà tempo è esponenziale
> >
>
> 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
Questo qui ci ha offesi, dovremo sfidarlo a duello prima o poi.
-
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.
> >
> > se con 20 impiega metà tempo è esponenziale
> >
>
> 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
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
http://challenge.greplin.com/
-
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.
> > >
> > > se con 20 impiega metà tempo è esponenziale
> > >
> >
> > 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
>
> 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
>
>
> http://challenge.greplin.com/
fico!
-
-
-
-
Re: @ avvelentaniScritto daavvelentaniCubicolarioil 2010-10-09 15:28:00.0 alle 2010-10-09 15:28:00.0Trollate totali: 18184
- 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.
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
I think happiness is love
- Vladimir Putin-
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.
>
> 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
>

Però è più veloce il mio 1 - 1
-
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.
> >
> > 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
> >
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> Però è più veloce il mio 1 - 1
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?-
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.
> > >
> > > 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
> > >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> >
> > Però è più veloce il mio 1 - 1
>
> 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).
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.
-
-
Re: @ avvelentaniScritto daavvelentaniCubicolarioil 2010-10-09 16:19:00.0 alle 2010-10-09 16:19:00.0Trollate totali: 18184Allora 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-
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?
-
Re: @ avvelentaniScritto daavvelentaniCubicolarioil 2010-10-09 16:28:00.0 alle 2010-10-09 16:28:00.0Trollate totali: 18184
- 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?
>
ROSIK
I think happiness is love
- Vladimir Putin-
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?
> >
>
> ROSIK
Quoto
-
-
-
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?-
Re: @ avvelentaniScritto daavvelentaniCubicolarioil 2010-10-09 17:28:00.0 alle 2010-10-09 17:28:00.0Trollate totali: 18184
- 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
-
-
-
-
-
Re: @ avvelentaniScritto daNon Autenticatoil 2010-10-09 16:30:00.0 alle 2010-10-09 16:30:00.0
- 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.
Cazzo un venerdì notte indimenticabile
-
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.
>
> Cazzo un venerdì notte indimenticabile
Visti gli strascichi direi di si
-
-