Sucessor

[Guest Luis Felipe]

o meu professor da faculdade pediu para fazer um programa q lesse um numero de 0 a 60 e q mostrasse o seu sucessor ... beleza ate ai é bico ... mas ele qr q qd chegue a 60 mostre q o sucessor seja 0 e q não pode ser usado nada do tipo if, do while, when, nada disso. nenhuma estrutura de repetição ... como eu posso fazer isso?

[Durub]

Se não pode usar if/switch/etc, EU ACHO que não tem como fazer isso.

Teu professor é bobo?

Abraços.

[Micheus]

Se não pode usar if/switch/etc, EU ACHO que não tem como fazer isso.

Durubi, também achei estranho.

Mas será que não poderia ser fazendo uso de lista circular? Se ele já aprendeu sobre ponteiros e tal, daria para fazer com este recurso.

Um while, para "varrer" a lista, ele terá que usar de qualquer modo.

[KaKarotto]

Legal!!! É óbvio que é um desafio...

C...lho.... perdi uma hora nessa coisa, mas gostei...

Olha só, em linguagens fortemente tipadas, uma variável do tipo inteiro sempre vai armazenar o valor inteiro, mesmo se a conta der resto, ou seja, em ponto flutuante. Então:

60/60 =1

59/60 =0

58/60 = 0

57/60 = 0

....

0/60 = 0

A única divisão que dá 1 é a de 60/60.

Outra coisa importante:

60%60 = 0

59%60 = 59

58%60 = 58

57%60 = 57

.....

0%60 = 0

Sabendo que n%60 = n, você deve achar uma equação que somada com n%60 vai dar n+1, usando as particularidades da divisão.

Tipo: n%60 + [equação] = n+1

Note, n%60 é igual a n, exceto em 60%60.

MUITO LEGAL!!

Eu curto essas coisas... Não vou falar a solução senão estraga. Percebi que isso é um desafio e não se pode dar um exercício desse para quem está aprendendo agora, por isso tenho duas teses:

1ª Seu professor é demente.

2ª Ele na verdade propôs um desafio (não valendo nota) e você quer saber a resposta para dar uma de malandro e impressionar a única gostosa da sala né danado...

É possível, já codifiquei e deu certo. Considerando números inteiros de 0 até 60.

Manda isso para a área de entretenimento como desafio!!!! Nunca vi um desse.

Akeleabraço

[Guest Luis Felipe]

#include<stdio.h>

#include<stdlib.h>

int n, s;

int main(void)

{

printf("digite um numero: ");

scanf("%d", &n);

s=n%60+((n%60)/n );

printf("sucessor: %d", s);

printf("\n");

printf("\n\n\n");

system("pause");

}

é isso não é? ... vlw cara ... espero q o professor aceita ...

bom pelo menos eu fiz varias tentativas e deu certo. vlw

[KaKarotto]

Não, quando o usuário digitasse 60 ele não iria a zero na sua fórmula.

Vou matar a curiosidade, já deu pra perceber que tentou fazer. A solução que eu achei foi:

n=n%60+ [-(n/60)+1]

Vamos aos pontos críticos:

Para n=60

60%60 + [ - (60/60) + 1] =

0 + [-1 + 1]=

0

Para n=0

0%60+ [ - (0/60) + 1 ] =

0 + [ - 0 + 1 ]=

1

Agora para os casos gerais, seja lá qual for o valor, exemplo 58:

58%60 + [ - (58/60) + 1] =

58+[- 0 +1 ] = 59

Beleza? Essa foi a solução que eu encontrei mas podem existir outras.

Akeleabraço.

[Graymalkin]

Ótima solução, KaKarotto! Eu tinha imaginado que isso seria feito usando o limite do tipo (um short, por exemplo, suporta até 65536 - se você somar +1 ele vai para 0), mas não consegui fazer desse jeito.

Parabéns pela solução!

Abraços,

Graymalkin

[Guest Luis Felipe]

s=n%60+((n%60)/n );

usando isso ia dar sim ... porque no meu program funcionou:

veja bem:

n=60

s= 60%60+((60%60)/60)

s= 0 + (0/60)

s= 0

n=5

s=5%60 + ((5%60)/5)

s= 5 + (5/5)

s= 5 + 1

s= 6

n=59

s=59%60 +((59%60)/59)

s=59 + (59/59)

s=59 + 1

s=60

[Guest Luis Felipe]

vlw pela dica ... c não fossem vocês eu não teria pensado nessa resposta vlw ai.

[KaKarotto]

Hummmm, realmente funciona com o 60, eu não tinha pensado nisso. Uma das soluções que eu tinha encontrado tinha sido essa que você encontrou, porém eu tinha esquecido do porque não tinha dado certo.

Lembrei agora, se n fosse igual a zero, seu programa ia falhar e falhar feio, já que não se pode fazer divisão por ZERO, portanto, usar qualquercoisa/ZERO é erro.

n%60+((n%60)/n )

Use o N como sendo 0 e seu programa no Dev vai simplesmente fechar, dando erro de execução.

Cuidado com essas coisas, não é só fazer funcionar, tem que pensar nos pontos críticos.

Ótima solução, KaKarotto! Eu tinha imaginado que isso seria feito usando o limite do tipo (um short, por exemplo, suporta até 65536 - se você somar +1 ele vai para 0), mas não consegui fazer desse jeito.

Parabéns pela solução!

Abraços,

Graymalkin

Obrigado MESTRE!!! Eu to aprendendo... =P

Akeleabraço

[*kurama*]

é mesmo eu não tinha pensado nisso ... vlw

[== Douplus ==]

Minha maneira:

#include <stdio.h>

int main(void)
{
  int input;

  scanf("%d", &input);
  printf("%d\n", (input + 1) % 61);
  return 0;
}

Abraços!

Editado Março 15, 2008 por == Douplus ==

[*kurama*]

O professor acabou aceitando o meu jeito de fazer ... vlw agradeço muito pela ajuda de vocês foram feitas 3 maneiras de resolver esse programa de sucessor, q foram entregues por alunos e a do professor foi outra maneira q escreverei a baixo para mostrar q existem diversas maneiras não é??!

s=(n+1)%61

para:

n=0

s=(0+1)%61

s=1%61

s=1

sucessor de 0 é 1.

n=57

s=(57+1)%61

s=58%61

s=58

sucessor de 57 é 58.

n=60

s=(60+1)%61

s=61%61

s=0

sucessor de 60 é 0.

Bom ai esta a solução do professor, axei mais simples ... me matei de pensar em uma maneira e era uma coisa assim tão simples ... mas acabei aprendende varias maneiras de se fazer uma coisa só..

abraços

[KaKarotto]

NOssa muito legal essa solução! Bem mais simples, eu jamais iria pensar numa solução dessas...

Foi a mesma solução do Douplus.

Legal!! o/