Newsgroup: it.comp.os.linux.iniziare
Titolo: sistemi totocalcio

Qualcuno sa indicarmi dei programmi per sviluppare sistemi al 
totocalcio, totogol, superenalotto...... che giri sotto linux?
Ciao

 Ciao
Google é da quella parte (c) -->  
-- 
Signature automatica inserita a mano.
Togliere NO SPAM scritto al contrario.
In God we trust, all others we monitor 
(National Security Agency)

 Qualcuno sa indicarmi ]...]
http://www.freshmeat.net
http://www.sf.org
http://www.linux.org
http://www.linuxapps.com
http://www.linuxgames.com
-- 
Sabatino
*** Sequenza di reboot:
        Carol - Alt - Del

 totocalcio, totogol, superenalotto...... che giri sotto linux?
Volendo citare una risposta ad una domanda simile su i.c.java:
"
// Superenalotto
for (int i = 0; i < 6; i++)
  System.out.println((int)(Math.random() * 90) + 1);
// Lotto (terno secco)
for (int i = 0; i < 3; i++)
  System.out.println((int)(Math.random() * 90) + 1);
Vincite garantite!
Rilasciato su licenza GPL, modificabile a piacere.
"
-- 
Giambo - Occhio al filtro antispam _e_ alla whitelist !

   System.out.println((int)(Math.random() * 90) + 1);
tu ci ridi sopra, ma statisticamente hai perfettamente ragione, questo e'
il miglior metodo! (a patto di avere un metodo random davvero casuale)
-- 
25/1/2005 | -2 all' alba!


Il sistema ha un bug... potrebbero uscire due numeri uguali!!

 Il sistema ha un bug... potrebbero uscire due numeri uguali!!
vabe', con restituzione, senza restituzione... comunque il numero di
estrazioni e' molto piccolo rispetto alla popolazione, e le distribuzioni
binomiale e ipergeometrica sono simili in queste condizioni...
(ok, fatemi dare l' esame di statistica e la smetto)
uff... va meglio cosi'?
#include <iostream>
#include <cstdlib>
#include <ctime>
int pesca() {
  static const double divisore = (1.0 + RAND_MAX)/90.0;
  return static_cast<int>(rand()/divisore)+1;
}
void estrazione(int a[], int b) {
  for (int i=0; i<b; i++) {
    bool presente=false;
    do {
      presente=false;
      a[i]=pesca();
      for (int j=0; j<i && !presente; j++)
        if (a[i]==a[j])
          presente=true;
    } while (presente);
  }
}
using std::cout;
using std::endl;
int main() {
  srand(static_cast<unsigned>(time(0)));
  int superenalotto[6];
  int terno_secco[3];
  //eseguo le estrazioni
  estrazione(superenalotto, 6);
  estrazione(terno_secco, 3);
  //stampa
  cout<<"Superenalotto"<<endl;
  for (int i=0; i<6; i++)
    cout<<superenalotto[i]<<" ";
  cout<<endl<<"Terno secco"<<endl;
  for (int i=0; i<3; i++)
    cout<<terno_secco[i]<<" ";
  cout<<endl;


 uff... va meglio cosi'?
[37righedicodice]
#!/usr/bin/env python
import random
def estrazione(massimo, numeri):
    nums = []
    nums.append(0)
    for i in range(numeri):
        n = 0
        while n in nums:
            n = int(random.random() * massimo + 1)
        nums.append(n)
    nums.remove(0)
    return nums
print "Terno secco: %s" % (estrazione(90, 3))
37 contro 13... python rulez!
Pedonzolo
-- 
- Mamma, e' vero che quando si muore si diventa polvere?
- Si', Pierino.
- Allora, sotto il mio letto ci sono un sacco di cadaveri!
		-- Da it.hobby.umorismo


Bella prova Pedonzolo!!
Un'altra dimostrazione di superiorità di Python sul tanto blasonato Java.
MarcoL.

 MarcoL.
Chiedo venia!!!
Quě si tratta di C++, ma i rapporti (numero di righe di codice) credo 
siano gli stessi.

 37 contro 13... python rulez!
erh... e' una gara?
#!/usr/bin/perl
sub estrai {
        my (%numeri);
        while (keys %numeri < $_[1]) { $numeri{int(rand($_[0]))+1}=$i }
        foreach (keys %numeri) { print $_, " " }
        print "\n"
}
&estrai (90, 3)
10 righe. 


 10 righe. 
#!/usr/bin/env python
import random
nums = [0]
for i in range(3):
    n = 0
    while n in nums: n = int(random.random() * massimo + 1)
    nums.append(n)
print "Terno secco: %s" % (nums[1:])
8 linee, e si capisce di più. (mi sa che tra poco arriveremo a una linea con 471982 caratteri...)
Pedonzolo
-- 
Se il male puzza, il bene manda forse odore di rose?

 10 righe.
Cosi' per giocare (so che è illeggibile e men che meno elegante...:) )
#include <stdio.h>
#include <stdlib.h>
int main(int argn,char** argv) {
	int* mem=calloc(93,sizeof(int));
	srand(atoi(argv[1]));
	while (++(mem[91])<=6 && (mem[mem[92]=random()%89+1]==0)?(printf("%d°
estratto: %d\n",mem[91],mem[mem[92]]=mem[92])>=0):(--mem[91]<6));
}
ho limato il massimo che ho potuto...perfino le dichiarazioni delle
varibili...:)
Estrae 6 numeri da 1 a 90 senza ripetizioni.
Il seme si passa come argomento (altrimenti il #include <time.h> mi ciullava
una riga :) )
....cmq 7 righe...in C...Simpatico no?
:)
Ciauuuuuuu
Menez
 
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 print "Terno secco: %s" % (nums[1:])
in effetti ci sto lavorando... :)
per ora ho solo questo...
#include <stdio.h>
#include <stdlib.h>
int main(int argn,char** argv) {
	int* mem=calloc(93,sizeof(int));
	srand(atoi(argv[1]));
	while (++(mem[91])<=6 && (mem[mem[92]=random()%89+1]==0)?(printf("%d°
estratto: %d\n",mem[91],mem[mem[92]]=mem[92])>=0):(--mem[91]<6));
}
7 righe...in pessimo C....
Si'...lo so...sono matto...
Ciauuuu


 :)
LOL
l'informatica e' uno di quei rari ambiti umani dove si fa a gara a chi
ce l'ha piu' corto! :D
-- 
l'importante e' non smettere mai di porsi domande

 
$ echo  Terno secco: 4 17 71
Una riga, e senza compilatori, interpreti, ammennicoli vari. :-)
OK, OK, mettete giu' i forconi e le fiaccole, me ne vado.
PS Perche' scomodare un generatore pseudorandom e un linguaggio?
Li chiedete a me, e tre numeri a caso ve li sparo anch'io.
C'e' gente che ci campa, in tv, con queste cose. :-(
-- 
           |Save our planet!
    Ciao   |Save wildlife!
   roberto |For your E-MAIL use ONLY recycled Bytes  !!
           |roberto poggi   
rpo...@softhome.net

 linea con 471982 caratteri...)
#!/usr/bin/perl
my %n;
while (keys %n < 3) { $n{int(rand(90))+1}=0 }
foreach (keys %n) { print $_, "\n" }
4 linee, 19 parole, 106 caratteri (she-bang incluso!)




Questo si chiama barare...
ti possono capitare 3 numeri uguali!
#!/usr/bin/python
import random
for i in range(3): print int(random.random() * 90 + 1)
3 linee...
Pedonzolo
-- 
Non sparate sul pianista.

 ce l'ha piu' corto! :D
erh...


 Un'altra dimostrazione di superiorità di Python sul tanto blasonato Java.
PFUI !!!
import java.util.*;
public class Test {
  public static void main(String[] args) {
    Set s = new HashSet();
    while (s.size() < 3) s.add(new Integer((int)(Math.random() * 90) + 1));
    System.out.println(s.toString());
  }
}
8 righe, altro che Python >:-> !!


 ti possono capitare 3 numeri uguali!
col cavolo
le chiavi dell' hash sono univoche ;PPP


Pensavo a ZeD, quando lessi...
gia' che ci siamo (m' e' venuta in mente stamattina... ok, sono da
sopprimere!)
#!/usr/bin/perl
while (keys %n < 3) { $n{int(rand(90))+1}=0 }
print join (' ', keys %n), "\n"
3 linee, 16 parole, 94 caratteri.


 3 linee, 16 parole, 94 caratteri.
azzz....questo è imbattibile per me col mio C...
Cmq sono riuscito a "rimpicciolirmelo" un po' anch'io... 5 righe...
#include <stdlib.h>
int main(int argn,char** argv) {
        srand((argv[0]=(char*)calloc(93,sizeof(int)))?atoi(argv[1]):1)
	while (++(argv[0][91])<=6 &&
(argv[0][argv[0][92]=random()%89+1]==0)?(printf("%d\n",argv[0][argv[0][92]]=argv[0][92])>=0):(--argv[0][91]<6));
}
...ricordate sempre che va passato il seme del generatore come parametro.
ciauuu


 }
oppero', non sara' piccolo come il mio, ma di sicuro e' piu'
incomprensibile ;P


 }
Puoi risparmiare la riga di srand
#include <stdlib.h>
int main(int argc,char** argv){
  for (srand((argv[0]=(char*)calloc(93,sizeof(int)))?atoi(argv[1]):1); ++(argv[0][91])<=6 && (argv[0][argv[0][92]=random()%89+1]==0)?(printf("%d\n",argv[0][argv[0][92]]=argv[0][92])>=0):(--argv[0][91]<6););
}
siamo a 4 righe, ma penso che un programma in C in meno di 4 righe sia
_veramente_ impossibile da fare (anche se in teoria dopo { e prima di }
non di deve essere _per forza_ un newline... quindi arriveremmo a 2 :-))
.a.
-- 
Il mattino ha l'oro in bocca. Il MATTino ha l'OrO In bOcca.
i lma tt ino ha l'o roin bocc a.ilmattinohal'oroinbocca. il ma tt in
oh al' or oi nb oc ca. il matti noha l'oroinbocca. IL MATtiNO Ha l'ORO
InBOCCa. I l m a t t i n o  h a l' o r o i n b o c c a . ilmattinohal'oroin
BoCcA. iLmAtTiNoHaL'oRoInBoCcA.

 3 linee, 16 parole, 94 caratteri.
ZeD ha segnalato questo thread su it.comp.lang.perl.
Aderisco al "golf" con questa versione liofilizzata dell'algoritmo 
di ZeD. Ho eliminato la she-bang, aderendo alla prassi comune delle
gare di golf [1]:
  {$n{int(rand(90))+1}++;@v=keys%n;@v<3&&redo}print"@v\n"
Sono 56 caratteri.
ciao,
S.
[1] Se qualcuno vuole provare a cimentarsi:
 
http://perlgolf.sourceforge.net/
-- 
Stefano Rodighiero      |  
http://larsen.perlmonk.org
mailto:
lar...@perl.it
   |  
http://www.perl.it

> Sono 56 caratteri.
{$n{int(rand 90)+1}++;@v=keys%n;@v<3&&redo}print"@v\n"
55!
(ho tolto le parentesi attorno al 90)


 Sono 56 caratteri.
mi inchino davanti ai potenti.
(tra l' altro neanche sapevo delle gare di "golf" in perl O_o)
appro, se hai in mente altri "algoritmi" per la risoluzione del problema
sei il benvenuto...


 sei il benvenuto...
Come ho scritto su it.comp.lang.perl la "nostra" soluzione (cioe`
il tuo procedimento via via accorciato da me e te) non e` un 
algoritmo, poiche` potrebbe non terminare mai: nulla assicura che
rand() non continui a restituire lo stesso numero.
Per esercizio, e per vedere cosa saltava fuori, ho provato a
scriverne una versione Lisp, che mima il processo di estrazione
cosi` come avviene nella realta`:
    (defvar *urna* (loop for n from 1 to 90 collect n))
    (defun estrai (u)
      (let ((numero (nth (random (length u)) u)))
      (delete numero u)
      numero))
    (defun stampa-terno ()
     (format nil "~{~A ~}"
      (loop for n below 3
           collect (estrai *urna*))))
*Attenzione*: nel programma c'e` un errore di off-by-one, e 
molto probabilmente e` scritto coi piedi. Quindi e` da prendere
con beneficio d'inventario.
Senza contare che siamo violentemente off-topic qui dentro (e
neppure saprei dove mandare il follow-up, avendo tirato in causa
piu` argomenti di quante ne son capitate a Bertoldo...)
ciao,
S.


 piu` argomenti di quante ne son capitate a Bertoldo...)
erh... boh...


 gare di golf [1]:
Scusate l'ignuranza, ma che cos'è una she-bang?
MarcoL

 Scusate l'ignuranza, ma che cos'è una she-bang?
 
http://en.wikipedia.org/wiki/Shebang
Quindi molto probabilmente la dizione "she-bang" me la sono
inventata io.
ciao,
S.


 
Tanto per tornare al problema originale, la mia domanda da profano quale 
sono (è per questo che ho scelto la newsgroup "iniziare"), tradotta in 
linguaggio binario è la seguente: qualcuno sa indicarmi un programma per 
elaborare sistemi al totocalcio, superenalotto, ecc... che giri sotto 
Linux???
Vorrei cioè sapere l'indirizzo dove poter trovare un programma del 
genere per scaricarmelo sull'harddisk. Ce ne sono migliaia, ma per Linux 
nisba...
Grazie e ciao.