Esercizio 1

[imported_ShuraBozz]

Se prendiamo in considerazione tutti i numeri naturali minori di 10 e multipli di 3 o 5 sono 3, 5, 6 e 9 e la loro somma è 23.

Trovare la somma di tutti i numeri naturali minori di 1000 multipli di 3 o 5.

Soluzione in C:
http://shurabozz.pastebin.com/f2a607b6f

 

[imported_opocaj]

[Perl]

#!/usr/bin/perl
$sum=0;
for ($i=0; $i<1000; $i++) {
  if ($i%3==0 || $i%5==0) {
    $sum+=$i;
  }
}
print $sum;

 

[meh.]

lulzJS:

total = 0;
(1).upTo(999, function (n) { if (n % 3 == 0 || n % 5 == 0) total += n });
print(total);

 

[GenKs]

Il mio in C:

#include <stdio.h>
#define MAX 1000

void somman35(int x, int &somma);

main()
{
      int i=0, somma=0;
      somman35(i,somma);
      printf("La somma dei numeri primi multipli di 3 e 5 e': %d\n", somma);
}

void somman35(int x, int &somma)
{
    if(x<=MAX)
    {
               if(x%3==0 || x%5==0)
               somma+=x;
               x++;
               return somman35(x,somma);
    }
}

spero che non fa niente se l'ho fatto anche io in C. Se no lo faccio in PHP stasera.

 

[imported_lepa]

il mio in c++

#include <cstdio>

inline bool multiplo (int numero, int sottomultiplo)
{
   return ! (bool)(numero % sottomultiplo);
}

int main (int argc, char **argv)
{
  int x,somma;
  for (x=0; x<1000; x++)
    if (multiplo(x,3) || multiplo(x,5)) 
       somma+=x;
  std::printf("La somma dei numeri multipli di 3 e 5 minori di mille è %d\n",somma);
  return 0;
}

 

[Robertof]

PHP (scritto al momento; non testato):

<?php
$sum = 0;
for ($i=0;$i<1000;$i++) {
    if ($i % 3 or $i %5) {
        $sum += $i;
    }
}
print $sum."\n";
?>

 

[meh.]

[ot]
lepa, non e' il massimo fare una funzione (per quanto inline) per una cosa del genere :S

Anche perche' l'if e' inutile.

Se proprio vuoi avere multiplo fai un define:

#define multiplo(a,b) (a % b == 0)

Se preferisci l'inline levami quell'if che mi fa venire il male estremo
[/ot]

 

[imported_lepa]

sarà, ma non riesco a farmi venire in mente come fare la stessa funzione senza if....

edit: forse ho capito

 

[kr1pn0$]

RUBY

####################
# Esercizio 1                         #
####################
n = 0
n.times do |x|
    if x%3==0 or x%5==0
         som += x
    end
end

 

[_Wizard]

Manca solo python:

#!/usr/bin/python
l = [];
for i in range(0,1000):
	if i % 3 == 0 or i % 5 == 0:
		l.append(i);
print sum(l);

 

[R4z0r_Cr4sH]

wizard manca in java...eccolo qua:

public class Es1{
    public static void main(String[] args){
        int c=0;
        for(int i=0;i<1000;i++){
            if(i%3==0 | i%5==0){
                c+=i;
            }
        }
    }
}

 

[lumo]

anche se il topic è vecchio, posto un procedimento che ho appena trovato
consideriamo la somma dei multipli di m fino ad n come:
m*1+m*2+m*3+...+m*n
si vede subito che si può raccogliere m, quindi
m( 1+2+3+...+n )
grazie a Gauss, sappiamo che per trovare la somma dei primi n naturali basta fare n(n+1)/2 quindi
m( n(n+1)/2 )
ora, è logico che basta un semplice calcolo per trovare la somma dei multipli di 3 e 5 fino ad n:
(codice in falcon)

nsum = { n => (n++*n)/2 }
function sumOfNMod3or5( n ) // bel nome del pazzo asd
    return 3 * nsum( int( n/3 ) ) + 5 * nsum( int( n/5 ) ) - 15 * nsum( int(n/15) )
end
> sumOfNMod3or5( 999 )

 

[phantom.ffff]

visto che ormai è gia uppato ne approfitto per postare il mio in C:

#include <stdio.h>

int multiplo(int x,int y) {
     if(x%y==0)
               return(1);
     return(0);
}
int main() {
    int max = 1000;
    int n = 1;
    int sum = 0;
    while(n <= 1000) {
            if((multiplo(n,3)) == 1 || (multiplo(n,5)) == 1) {
                        sum += n;
            }
            n+=1;
    } 
    printf("%d",sum);
}

 

[fojeaf]

Manca solo python:

#!/usr/bin/python
l = [];
for i in range(0,1000):
	if i % 3 == 0 or i % 5 == 0:
		l.append(i);
print sum(l);

visto che tu hai voluto usare una lista e sum, ora faccio anche io il mona ed uso la lambda

import functools
print(functools.reduce(lambda x,y : x+y if not y%3 or not y%5 else x,range(0,1000)))

Python 3.1

 

[PowerOfMind]

	.section	.rodata
.LC0:
	.string	"%d\n"
	.text
.globl main
	.type	main, @function
main:
	pushl	%ebp
	movl	%esp, %ebp
	andl	$-16, %esp
	subl	$32, %esp
	movl	$0, 28(%esp)
	movl	$0, 24(%esp)
	jmp	.L2
.L5:
	movl	24(%esp), %ecx
	movl	$1431655766, %edx
	movl	%ecx, %eax
	imull	%edx
	movl	%ecx, %eax
	sarl	$31, %eax
	subl	%eax, %edx
	movl	%edx, %eax
	addl	%eax, %eax
	addl	%edx, %eax
	movl	%ecx, %edx
	subl	%eax, %edx
	testl	%edx, %edx
	je	.L3
	movl	24(%esp), %ecx
	movl	$1717986919, %edx
	movl	%ecx, %eax
	imull	%edx
	sarl	%edx
	movl	%ecx, %eax
	sarl	$31, %eax
	subl	%eax, %edx
	movl	%edx, %eax
	sall	$2, %eax
	addl	%edx, %eax
	movl	%ecx, %edx
	subl	%eax, %edx
	testl	%edx, %edx
	jne	.L4
.L3:
	movl	24(%esp), %eax
	addl	%eax, 28(%esp)
.L4:
	addl	$1, 24(%esp)
.L2:
	cmpl	$1000, 24(%esp)
	jle	.L5
	movl	$.LC0, %eax
	movl	28(%esp), %edx
	movl	%edx, 4(%esp)
	movl	%eax, (%esp)
	call	printf
	movl	$0, %eax
	leave
	ret

---

oppure in C:

// Per la compilazione bisogna aggiungere -std=c99
// Ai parametri..
#include <stdio.h>

int main() {
	int sum = 0;
	for(int n = 0; n <= 1000; n++) {
		if(n%3==0 || n%5==0) {
			sum += n;
		}
	}
	printf("%d\n",sum);
}

sotto linux con gcc va compilato cosi:

gcc -o nome_eseguibile nome_sorgente.c -std=c99

 

[lumo]

è una coincidenza che quell'asm sia proprio quello generato da gcc usando l'opzione -S? xD
EPIC FAIL

 

[fojeaf]

è una coincidenza che quell'asm sia proprio quello generato da gcc usando l'opzione -S? xD
EPIC FAIL

lol. effettettivamente sembrava un asm un po' "anonimo"

 

[PowerOfMind]

è una coincidenza che quell'asm sia proprio quello generato da gcc usando l'opzione -S? xD
EPIC FAIL

lol. effettettivamente sembrava un asm un po' "anonimo"

Infatti si poteva notare ^^ lo so non ho detto che lo scritto io quel asm ^^ per 2 semplici motivi:
1) Ci sono molte informazioni di Debug
2) è + semplice da compilare perchè inizialmente avevo postato l asm perchè il codice C richiedeva che venisse aggiunto -std=c99 ossia che quel codice si basava sullo standard 99 ed con un gcc nome.S era molto + semplice di un gcc -o nome nome.C -std=c99, comunque tranquilli non sono ancora arrivato la sono appena arrivato al input e output

 

[cyd]

il codice C richiedeva che venisse aggiunto -std=c99

dichiara n insieme a sum e hai risolto

 

[PowerOfMind]

Lo so che uppo una discussione del 1300 a.C ma propongo il mio esercizio In ruby sta volta:

k = [] and x = 0
k << x+=1 while(x<1000)
k.inject{|som,y| som += y if y%3==0 or y%5==0}

 

[Cynical]

Ho generalizzato la soluzione....

/* Testo :
   "If we list all the natural numbers below 10 that are multiples 
   of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.
   Find the sum of all the multiples of 3 or 5 below 1000".

   Io ho deciso di generalizzare la soluzione :
   dati r numeri il programma calcolerà la sommatoria di tutti i multipli
   di questi numeri minori o uguali ad un certo n. 
*/

#include <stdio.h>
#include <stdlib.h>

int mCd(int a,int b);  // calcola il massimo comun divisore tra a e b....
int mCm(int a,int b); // calcola il minimo comune multiplo tra a e b...
int leggiNum(void);
int somMultipli(int k, int lim);

int main(void)
{ int lim,sum,i,j,r; 

  printf("quanti sono i numeri?\n");

  r = leggiNum();
  int num[r];
  
  printf("inserisci gli %d numeri : ",r);
  for(i=0;i<r;i++)
      num[i] = leggiNum();
  
  printf("i numeri devono essere minori di?\n");  
  lim = leggiNum();

  sum = 0;
  for(i=0;i<r;i++)
    sum += somMultipli(num[i],lim);
   

  // adesso escludo i multipli comuni....
  for(i=0;i<r;i++)
     for(j=i+1;j<r;j++)
         sum -= somMultipli(mCm(num[i],num[j]), lim);
  
  printf("Ecco la sommatoria dei multipli degli elementi inseriti:\n%d",sum);
  
  printf("\n\npremere un tasto per continuare...\n");
  while(getchar() != '\n');

  return 0;
}

int leggiNum()
{ int r;
  
  do { scanf("%d",&r);
       if(r<1)
           printf("\nERRORE : inserisci un numero maggiore o uguale a 1\n");
     } while(r<1);

 return r;
}

int somMultipli(int k, int lim)
{ 
  lim--;
  while(lim % k)
        lim--;
  
  return (lim*(lim + k)) / (2*k);
}

int mCd(int a, int b)
{ int r;
  
  if(b<a && (r = a%b))
        return mCd(b,r);
  else 
       if(a<b && (r = b%a))
             return mCd(a,r);

  return (a<b)? a:b;
}

int mCm(int a, int b)
{
  return (a*b)/mCd(a,b);
}

 

[G164H4x0r]

(1..999).select {|x| x % 3 == 0 or x % 5 == 0 }.inject(:+)

.

 

[imported_Bronsa]

(apply + (filter #(or (zero? (rem % 3)) (zero? (rem % 5))) (range 1 999)))

 

[EvilMau]

RB:

tot = 0 and (1..999).each {|x| tot+=x if x % 3 == 0 or x % 5 == 0 }

---

[ot]Shura lo sto leggendo il file che mi hai passato =) non l'avevo mai visto comunque molto interessante ^^ [/ot]

 

[G164H4x0r]

Non capisco perché quel "to_enum", Range ha il metodo each
Un'altra variante è 1.upto(999), che sarebbe più carino nel tuo caso.

[ot]quello è già deprecato per quanto riguarda la documentazione delle classi builtin, cioè, ora ci sono più metodi e non so se ne hanno tolto qualcuno, tieni conto che quello è per 1.9.1, ora siamo a 1.9.2, non ci dovrebbe essere un grande divario[/ot]