Como organizar 3ºs em ordem crescente sem o "IF"

[Visitante]

Oi amigos, eu estou querendo saber se isso é possível? Uma organização 3 números em ordem crescente sem ultilizar o "IF". Por favor mostre o código fonte desta programação. A linguagem em referência a C. Bem amigos , fico grato pela conpreeensão de todos.

[gegel]

Os 3 numeros estão em um vetor?

[Visitante]

Vetor? O que será isso amigo.

[Zangrela]

Impossivel !

Como você vai comparar os números sem if?

Que ####### de questão é essa ?

[Skelton]

Sem comparar os valores não tem como fazer com que eles sejam ordenados. E não dá pra comparar sem a função if (provavelmente, pois não conheço o suficiente pra dizer nada categoricamente).

Me passou pela cabeça fazer com do-while. Depois com laço for. Daí me apareceu a ideia de jogar em um vetor. E, finalmente, fazer a média de dois desses numeros e comparar com o terceiro. Mas nenhuma ideia dessa foi pra frente pois TODAS elas passavam obrigatoriamente pelo if.

Não me leve a mal, mas porque reinventar a roda e fazer um trabalho de maneira tão difícil, se no caso isso pode ser feito facilmente com if? Seria alguma coisa relacionada a tarefa que algum professor pediu, ou apenas uma dúvida?

Se for um professor que pediu, e depois ele mostrar como faz, peço que coloque aqui o que ele disser, pra que nós todos possamos ver o malabarismo que torna o impossível possível.

[Visitante]

É amigo skelton, foi o professor que passou esta tarefa, eu não sei o por quê? É um desafio para a turma, é só isso que eu sei?

[gustavoprogrammer]

O if é essencial porque é ele quem vai testar e comparar para depois sim mostrar qual é a ordem que ele precisa seguir , lembrando que quem precisa especificar isso é você>>>>>>

if (n1<n2) and (n2<n3) then

write (n1,n2,n3)

é algo assim que você deve fazer para que ele mostre a ordem crescente dos números.

[AzaZell]

Postado Originalmente por homem massa@23 de março de 2005, 01:38

Oi amigos, eu estou querendo saber se isso é possível? Uma organização 3 números em ordem crescente sem ultilizar o "IF". Por favor mostre o código fonte desta programação. A linguagem em referência a C. Bem amigos , fico grato pela conpreeensão de todos.

←

Tem várias maneiras de fazer isso... vê se essa serve...

#include<iostream>

using namespace std;

#define SATISFAZ ?
#define SENAO :

void fnPrintAscendent( int *x, int *y, int *z ) {

   *x < *y SATISFAZ
      *y < *z SATISFAZ
         cout<<*x<<*y<<*z<<endl
      SENAO
         *x < *z SATISFAZ
            cout<<*x<<*z<<*y<<endl
         SENAO
            cout<<*z<<*x<<*y<<endl
   SENAO
   *y > *z SATISFAZ
      cout<<*z<<*x<<*y<<endl
   SENAO
      *x > *z SATISFAZ
         cout<<*y<<*z<<*x<<endl
      SENAO
         cout<<*y<<*x<<*z<<endl;
}

int main() {

   int x,y,z;

   cin>>x>>y>>z;

   fnPrintAscendent( &x, &y, &z );

   return 0;
}

[AzaZell]

De um outro modo:

#include<iostream>

bool Se( int p_nA, int p_nB ) {

   return p_nA > p_nB;
}

void Troca( int &p_nA, int &p_nB ) {

   int l_nTemp;

   l_nTemp = p_nA;
   p_nA    = p_nB;
   p_nB    = l_nTemp;   
}

int main() {

   using namespace std;

   int l_nA, l_nB, l_nC;

   cout<<"Digite 3 numeros: "<<endl;
   cin>>l_nA>>l_nB>>l_nC;

   while( Se( l_nA, l_nB ) ) {

      Troca( l_nA, l_nB );
   }

   while( Se( l_nB, l_nC ) ) {

      Troca( l_nB, l_nC );
   }

   while( Se( l_nA, l_nB ) ) {

      Troca( l_nA, l_nB );
   }

   cout<<"Os 3 numeros ordenados:"<<endl;
   cout<<l_nA<<" "<<l_nB<<" "<<l_nC<<endl;

   return 0;
}

Digite 3 numeros:

3 2 1

Os 3 numeros ordenados:

1 2 3

[klaux]

Muito tosco, mas possível...

#!/bin/sh

[ "$1" ] && [ "$2" ] && [ "$3" ] || echo "Usage: ./$0 <INT> <INT> <INT>"
echo

unset R1 R2 R3

(( $1 <= $2 )) && (( $1 <= $3 )) && (( $2 <= $3 )) && R1=$1 && R2=$2 && R3=$3
(( $1 <= $2 )) && (( $1 <= $3 )) && (( $2 >= $3 )) && R1=$1 && R2=$3 && R3=$2
(( $1 >= $2 )) && (( $1 <= $3 )) &&                   R1=$2 && R2=$1 && R3=$3
(( $1 >= $2 )) && (( $1 >= $3 )) && (( $2 <= $3 )) && R1=$2 && R2=$3 && R3=$1
(( $1 <= $2 )) && (( $1 >= $3 )) &&                   R1=$3 && R2=$1 && R3=$2
(( $1 >= $2 )) && (( $1 >= $3 )) && (( $2 >= $3 )) && R1=$3 && R2=$2 && R3=$1

echo "Entrada [ $1, $2, $3 ]"
echo "Saída   [ $R1, $R2, $R3 ]"

[Bnezinho]

Diferente do que muitas pessoas afirmaram aqui, é possível sim, e bem mais fácil do que você imagina. Como desconheço essa linguagem, mostrarei-te o código em Portugol:

Vars Inteiro : a, b, c;
Tipo Crescente = vetor[1:3]inteiro;
Inicio
 ler(a,b,c,Crescente);
 Caso a
   Quando a > b e a > c
      Crescente[1] <- a;
      Caso b
       Quando b < a e b < c
          Crescente[3] <- b;
          Crescente[2] <- c;
       Fim_de_caso
       Caso c
         Quando c < a e c < b
           Crescente[3] <- c;
           Crescente[2] <- b;
         Fim_de_Caso
  Fim_de_caso
  Caso b
    Quando b > a e a > c
       então Crescente[1] <- b;
       Caso a 
           Quando a < b e a < c
               Crescente[3] <- a;
               Crescente[2] <- c;
       Fim_de_caso
       Caso c
           Quando c < b e c < a
               Crescente[3] <- c;
               Crescente[2] <- a;
       Fim_de_Caso
  Fim_de_Caso
  Caso c
     Quando c > a e c > b
        Crescente[1] <- c;
        Caso a
            Quando a < c e a < b
               Crescente[3] <- a;
               Crescente[2] <- b;
        Fim_de_Caso
        Caso b
             Quando b < c e b < a
                Crescente[3] <- b;
                Crescente[2] <- a;
        Fim_de_Caso
  Fim_de_Caso
escrever('Os três numerais em ordem crescente:' Crescente)
Fim 

Case, When, também é uma estrutura condicional, lembre-se disso

PS: Em Ruby, existe um método chamado sort que reorganiza a array (vetor) automagicamente ^^

[index.xp]

laços de repetição nao contam galera:

repeat,while e qualquer outro na verdade é um pointer + if... exemplo:

enquanto i<3 faça

bla bla bla b

na verdade é

:ponto1

bla bla bla

IF i<3

then goto ponto1

[Goliathvv]

O index.xp levantou um bom ponto. Basicamente qualquer instrução condicional é implementável utilizando um laço.

Inclusive se você quiser criar uma linguagem "Bare Bones"(ou seja, que contém apenas o essencial), basta que você tenha uma instrução para executar laços(além de instruções básicas de atribuição e cópia de valores), que as demais instruções são implementáveis a partir desta. Veja aqui um link com um exemplo.

Apesar de este tópico ser de 2005 vou deixá-lo aberto por hora.

Abraços.

[apollomission19]

Essa é gira mas brainfuck ainda é mais giro.

http://www.muppetlabs.com/~breadbox/bf/