Mesclar dois valores

44

Você tem dois valores, cada um dos quais 0representa "desconhecido" ou um de 1,2,3. Mesclá-los em um único valor da seguinte maneira:

  • Se ambos os valores forem diferentes de zero e iguais, produza esse valor:
    (3,3) -> 3
  • Se ambos os valores forem diferentes de zero, mas desiguais, forneça 0 para desconhecido:
    (1,2) -> 0
  • Se um valor for zero e o outro não, envie o valor diferente de zero:
    (2,0) -> 2, (0,1) -> 1
  • Se os dois valores forem zero, dê saída zero:
    (0,0) -> 0

Casos de teste:

Existem 16 pares de entradas possíveis.

  | 0 1 2 3
--+--------
0 | 0 1 2 3
1 | 1 1 0 0
2 | 2 0 2 0
3 | 3 0 0 3

(0, 0) -> 0
(0, 1) -> 1
(0, 2) -> 2
(0, 3) -> 3
(1, 0) -> 1
(1, 1) -> 1
(1, 2) -> 0
(1, 3) -> 0
(2, 0) -> 2
(2, 1) -> 0
(2, 2) -> 2
(2, 3) -> 0
(3, 0) -> 3
(3, 1) -> 0
(3, 2) -> 0
(3, 3) -> 3

Classificação

Mostrar snippet de código

code-golf 
— xnor
fonte
8
A quarta regra se encaixa na primeira, então não sei por que você as separou.
— Fatalize
1
Nitpick: O quarto ponto é redundante, você pode simplesmente remover "diferente de zero" do primeiro ponto. EDIT: Uau, o que é um ninja @Fatalize.
— Erik the Outgolfer
Além disso, 3 não é realmente necessário aqui, embora aumente o número de entradas possíveis.
— Erik the Outgolfer
2
Eu considerei condensar as regras, mas achei que seria mais claro listar todos os casos zero / diferente de zero e deixar a otimização para os golfistas.
— xnor 25/05
2
Isso precisa de uma tabela de classificação , a primeira página está começando a receber respostas já batidas na segunda.
— Ørjan Johansen

Respostas:

22

Python 3 , 27 25 bytes

lambda x,y:(x|y)>>(x*y&2)

Experimente online!

— Dennis
fonte
5
Eu gosto que isso seja interrompido para entradas acima de 3. Como você chegou a isso?
— Jakob
4
Basicamente, muitas tentativas e erros.
— Dennis
1
Interessante. Por um momento, pensei em automatizar uma pesquisa por meio de expressões de comprimento limitado, envolvendo duas entradas e alguns operadores, mas o espaço é grande demais, mesmo em torno de 20 bytes. Alguma inteligência é necessária!
— Jakob
16

Gelatina , 4 bytes

gf|S

Experimente online!

Como funciona

gf|S  Main link. Left argument: x. Right argument: y.

g     Compute a, the gcd of x and y.
  |   Compute b, the bitwise OR of x and y.
 f    Filter; yield all common elements of [a] and [b].
   S  Take the sum.
— Dennis
fonte
10

APL (Dyalog) , 5 bytes

⌈×∧=⌊

Experimente online!

Referência útil

∧=⌊: Retorna 1se o múltiplo comum mais baixo for igual ao mínimo. Isso só é verdade se um dos valores for zero ou ambos forem iguais. Alternativamente, eu poderia ter=*⌊

⌈×: O máximo multiplicado pelo acima.

— H.PWiz
fonte
7

Linguagem de programação de Shakespeare , 296 bytes

Z.Ford,.Ajax,.Act I:.Scene I:.[Enter Ford and Ajax]Ajax:Listen to thy heart.Ford:Listen to thy heart.Am I as fat as you?Ajax:If so,let us Scene C.Am I as fat as zero?If so,let us Scene C.Ford:Am I as fat as zero?If not,you zero.open heart.let us Scene V.Scene C:.Ajax:open heart.Scene V:.[Exeunt]

Experimente online!

Primeira participação em um desafio de código-golfe, então vamos começar com uma das minhas linguagens de piadas favoritas!

Explicação: Declaração das duas variáveis ​​Ford e Ajax (nomes de variáveis ​​mais curtos disponíveis)

Z.Ford,.Ajax,.

Primeira cena: coloque os dois valores na variável, depois teste-os quanto à igualdade, depois teste o Ajax contra 0. Se o valor que precisamos retornar estiver armazenado na variável Ford, vá para a cena C.

Act I:.
Scene I:.
[Enter Ford and Ajax]
Ajax:
Listen to thy heart.
Ford:Listen to thy heart.
Am I as fat as you?
Ajax:
If so,let us Scene C.
Am I as fat as zero?
If so,let us Scene C.

Se Ford for 0, imprima Ajax, então defina Ajax como 0 e imprima Ajax. Então vá para o final do programa.

Ford:Am I as fat as zero?
If not,you zero.
open heart.
let us Scene V.

Cena C: Impressão Ford

Scene C:.
Ajax:open heart.

Cena V: Fim do programa.

Scene V:.
[Exeunt]
— Guillaume Ruchot
fonte
— Jo King
2
@JoKing: sua versão é inegavelmente melhor que a minha, acho que seria melhor se você a postasse como resposta, pois o raciocínio por trás do programa é bem diferente e não quero levar o crédito pelo seu trabalho
— Guillaume Ruchot
6

Ruby , 21 bytes

->a,b{(a|b)*531[a*b]}

Experimente online!

Porque Ruby

Breve explicação:

  • a|b é bitwse OU, portanto, nos dá o número certo se a == b ou um deles for zero.

  • O número mágico 531é 2 ^ 9 + 2 ^ 4 + 2 ^ 1 + 2 ^ 0 e o operador [] extrai um único bit. Isso significa: multiplique por 1 se a * b for 0, 1, 2, 4 ou 9, multiplique por 0 caso contrário.

  • Isso não funcionará para valores> 3
— GB
fonte
5

Pitão , 8 7 bytes

@{+0SQ3

Experimente online!

@{+0SQ3   Implicit: Q=input()

    SQ    Sort input
  +0      Prepend 0
 {        Deduplicate
@     3    Get 4th element (index 3), modular indexing

Caso 1 - Ambos os valores são diferentes de zero e iguais

Sorted Input   [3,3]
Prepend 0      [0,3,3]
Deduplicate    [0,3] - index 3 yields 3

Caso 2 - Valores diferentes de zero e desiguais

Sorted Input   [1,2]
Prepend 0      [0,1,2]
Deduplicate    [0,1,2] - index 3 yields 0

Caso 3 - Exatamente um valor zero

Sorted Input   [0,1]
Prepend 0      [0,0,1]
Deduplicate    [0,1] - index 3 yields 1

Caso 4 - Ambos os valores zero

Sorted Input   [0,0]
Prepend 0      [0,0,0]
Deduplicate    [0] - index 3 yields 0

Solução alternativa, também 7 bytes

*eSQ}s{

Experimente online

*eSQ}s{QQ   Trailing Q's inferred

      {Q    Deduplicate input
     s      Take the sum
    }   Q   Is this in the input? True treated as 1, false as 0
*           Multiplied by
 eSQ        Max from input (end of sorted input)

Versão anterior, 8 bytes

@+0{-QZ3
— Sok
fonte
@xnor Graças para detectar isso, deve ser corrigido agora
— Sok
@{+0Q3trabalha para 6 bytes.
— Sr. Xcoder
4

Stax , 8 bytes

Ç∞∟∙◄╥*♣

Execute e depure

Descompactado, não jogado e comentado, parece com isso.

    e.g.        [2, 0]
c:s [2, 0] 2    calculate the "span" of the input array (max(a) - min(a))
+   [2, 0, 2]   append the span to the input array
o   [0, 2, 2]   sort the 3-element array
E   0 2 2       explode the 3 elements into 3 separate stack entries
a   2 2 0       rotate the third stack element to the top of stack
!   2 2 1       logical not, produces 1 iff the top value was 0
*   2 2         multiply
                implicitly print top of stack

Execute este

— recursivo
fonte
4

C (gcc), 25 bytes

f(a,b){a=a^b&&a*b?0:a|b;}

pseudo-código:

foo(A,B)
    if A XOR B and A*B are > 0
        return 0
    else 
        return A OR B`
— Geo
fonte
3

C (gcc), 26 bytes

f(a,b){a=a*b?a-b?0:a:a+b;}

Experimente online!

Expanation / Ungolfed:

int f(int a, int b) { // implicit-int (C89)
    // return replaced with assignment: link
    return a*b ? // if a and b are both not zero, then
        a-b ? // if a != b
        0 : // a != b, so return 0
        a // a == b, so return a
    : a+b // one of a,b is zero, so return whichever is nonzero 
    ;
}
— pizzapants184
fonte
3

MATL , 9 bytes

dGp*~GX>*

Experimente online!

Explicação:

           % Implicit input as a vector with two elements implicitly. Stack: [0,2]
d          % The difference between the two elements. Stack: [2]
 G         % Push input again. Stack: [2], [0,2]
  p        % The product of the last element (the input). Stack: [2], [0]
   *       % Multiply the two elements on the stack. Stack: [0]
    ~      % Negate. Stack: [1]
     G     % Push input again. Stack: [1], [0,2]
      X>   % Maximum value. Stack: [1], [2]
        *  % Multiply the two elements on the stack. Stack: [2]
           % Implicit output
— Stewie Griffin
fonte
Outgolf com falha:t?td~*]X>
— sundar - Restabelece Monica
3

GNU sed, 23 bytes

s/^0?(.)\1?0?$/\1/
t
c0

(deve ser executado com -rsinalizador)

Experimente online!

— KernelPanic
fonte
1
Bem-vindo ao PPCG :) O consenso atual é que as bandeiras não sejam contadas (estou no meu telefone, portanto não consigo vincular o Meta relevante).
— Shaggy
1
Oh legal! Editarei mais tarde, pois também estou no meu telefone; um livre -3 bytes é um grande bem-vindo para PPCG :)
— kernel panic
3

QBasic, 34 bytes

Abordagem diferente!

INPUT a,b
?(a OR b)*-(a*b=0OR a=b)

Observe que os valores diferentes de zero na grade de saída são todos os bits ORdos dois números de entrada. Isso é apenas a OR bno QBasic. Queremos gerar esse valor quando a*b=0 OR a=b, e 0caso contrário, o que podemos fazer multiplicando pelo negativo do condicional mencionado acima (negativo, pois a verdade está -1em QBasic).

— DLosc
fonte
2

brainfuck, 25 bytes

,>,[>]<<[[->->+<<]>[>]]>.

A entrada tem dois valores de bytes (não ascii)

— KSab
fonte
2

Rápido , 118 bytes

func c(n1:Int,n2:Int){n1==n2 ? print("\(n1)") : (n1*n2 != 0 ? print("0") : (n1==0 ? print("\(n2)") : print("\(n1)")))}
— onnoweb
fonte
4
Bem-vindo ao PPCG! Eu não conheço Swift, mas você provavelmente pode economizar muitos bytes, tornando os nomes das variáveis ​​1 caracter cada e removendo o espaço em branco em torno de operadores como !=o ternário.
— Οurous
1
Olá, seja bem-vindo ao PPCG! Como mencionado por @ ousurous, você pode alterar n1e usar n2caracteres únicos para encurtá-los; remova alguns espaços em branco e parênteses e remova alguns espaços. Além disso, ==0pode ser <1e !=0pode ser >0, pois sabemos que apenas as entradas 0,1,2,3são possíveis. Nunca programei no Swift antes, mas eu o reduzi para 91 bytes como este: func c(a:Int,b:Int){a==b ?print("\(a)"):a*b>0 ?print("0"):a<1 ?print("\(b)"):print("\(a)")} Experimente online.
— Kevin Cruijssen
Além disso, parece que você pode reduzi-lo para 51 bytes assim: func c(a:Int,b:Int){print(a==b||a*b<1 ?max(a,b):0)} Experimente online. Mais uma vez bem-vindo ao PPCG, e aproveite a sua estadia!
— Kevin Cruijssen
1
Além dos campos de golfe de @ KevinCruijssen, você pode transformar seu envio em um fechamento anônimo para economizar 87 bytes: {$0==$1||1>$0*$1 ?max($0,$1):0} Experimente online!
— Sr. Xcoder
2

Lote, 38 36 35 30 bytes

@cmd/cset/a"(%1|%2)>>(%1*%2&2)

Resposta da porta do @ Dennis's Python, pois os condicionais são muito caros no lote.

— Neil
fonte
2

J , 8 7 bytes

1 byte salvo pelo H.PWiz. 

>.*=^<.

Experimente online!

Porta AJ da solução APL da H.PWiz

=os números são iguais? (resulta em 1 ou 0)

^ ao poder de

<. o número menor

* multiplicado por

>. o número maior

— Galen Ivanov
fonte
1
>.*=^<.para 7 bytes
— H.PWiz
@ H.PWiz Obrigado! Uso inteligente de =e ^!
— Galen Ivanov
2

05AB1E , 9 8 bytes

àIËIP_+*

-1 byte graças a @MagicOctopusUrn .

Experimente online ou verifique todos os casos de teste .

Explicação:

à         # Take the maximum of the input-list
          #  [0,2] → 2
IË        # Are all elements in the input-list equal?
          #  [0,2] → 0
  IP_     # Take the product of the input-list, and verify if it equals 0
          # (`_` transforms 0 into 1; everything else into 0)
          #  [0,2] → 0 (product) → 1 (==0)
     +    # Add them together (since only 1 is truthy in 05AB1E, this is basically an OR)
          #  0+1 → 1
*         # Multiply both values on the stack
          #  2*1 → 2

Explicação generalizada:

IËIP_+    # If both values are equal, or one of them is a zero:
 à        #  Output the maximum of the two values
          # Else:
          #  Output 0
— Kevin Cruijssen
fonte
Ës0å~iZë0era meu; Agradável. Na verdade, não tenho certeza de que você pode vencer 9 bytes por muito.
— Magic Octopus Urn
1
Eu levo isso de volta à®Ë®P_+*onde _é logicamente equivalente a>Θ
— Magia Octopus Urna
_Acontece 0 para 1, todos os outros valores em 0.
— Magia Octopus Urna
@MagicOctopusUrn Thanks! Quando dei essa resposta, estava examinando os documentos para ver se havia um == 0comando, não sabia que _faz exatamente isso. Também deve ser útil para outros desafios no futuro. TIL. :)
— Kevin Cruijssen
2

Javascript, 35 bytes

f=(m,n)=>(m||n)&&(m!=n)?(m>n?m:n):0
— david
fonte
2

Javascript ES6, 25 22 21 20 bytes

a=>b=>a?b-a?!b*a:a:b

14 13 bytes , se os argumentos forem fornecidos em ordem classificada

a=>b=>a%b?0:b
— MattH
fonte
2

QBasic, 38 36 35 bytes

INPUT a,b
?(a*b>0)*(b-a*(a<>b))+a+b

Parcialmente inspirado na IF ... THEN ... ELSEresposta de Erik , aqui está uma solução apenas matemática.

Como cheguei aqui

Nota importante para entender matemática com condicionais: no QBasic, os resultados dos operadores de comparação são 0e -1, não 0e 1.

Começamos com o código de Erik:

IF a*b THEN?a*-(a=b)ELSE?a+b

Em outras palavras, se ae bsão ambos diferentes de zero, então imprima a*-(a=b)( ase a=b, caso contrário 0); else (pelo menos um de ae bé zero), output a+b(o número diferente de zero ou 0se ambos são zero).

Já existe alguma matemática com condicionais acontecendo aqui. Vamos dar um passo adiante e ver se conseguimos eliminar IFcompletamente a afirmação. Teremos que usar a*b>0a condição externa: a*bpode ter vários valores de verdade diferentes, o que é bom, IFmas causa problemas para a matemática.

c=a*b>0
?c*a*(a=b)+(c+1)*(a+b)

Este é o truque padrão da IFeliminação. Quando cé verdade, c*a*(a=b)é -a*(a=b)e (c+1)*(a+b)é 0; Quando cé falso, c*a*(a=b)é 0e (c+1)*(a+b)é a+b. Portanto, essa expressão fornece os mesmos resultados que o IF ... THEN ... ELSE. O único problema é que ele torna o nosso programa 40 bytes em vez de 38. Talvez possamos reduzi-lo reorganizando a matemática.

c=a*b>0
?c*a*(a=b)+c*(a+b)+a+b

Ainda 40 bytes ...

c=a*b>0
?c*(a+b+a*(a=b))+a+b

Agora, nosso programa voltou aos 38 bytes. Mas como estamos usando apenas cuma vez, não precisamos mais atribuí-lo a uma variável:

?(a*b>0)*(a+b+a*(a=b))+a+b

Agora estamos com 36 bytes.

Mas espere, tem mais ... Essa a+b+a*(a=b)expressão parece um pouco redundante. a*(a=b)é -ase a=be 0caso contrário. Quando o adicionamos a, obtemos 0se a=be de aoutra forma. Talvez possamos conseguir a mesma coisa em menos bytes, revertendo a condição.

b+a*-(a<>b)

No começo, isso não parece mais curto. Mas podemos salvar um byte subtraindo em vez de adicionar um negativo:

b-a*(a<>b)

E aqui temos a nossa solução de 35 bytes.

— DLosc
fonte
Bom truque por lá ...
— Erik the Outgolfer
1

Limpo , 46 43 42 bytes

import StdEnv
?[a,b]|a<1||a==b=b=0


?o sort

Experimente online!

Composição anônima :: [Int] -> Int, classifica o par e depois corresponde ao primeiro membro.

Fazê-lo como um lambda composto tem o mesmo comprimento:

import StdEnv


(\[a,b]|a<1||a==b=b=0)o sort
— Furioso
fonte
1

Geléia , 7 6 bytes

׬o=a»

Experimente online! ou Experimente todas as combinações!

Quão?

׬o=a»   Dyadic link
×        Multiply the two arguments.
 ¬       Logical not. Gives 1 if one argument is 0, 1 otherwise.
   =     Are the two arguments equal?
  o      Logical or the result of = and ¬. 
     »   Greater of the two arguments.
    a    Logical and. Gives the greater of the two arguments if they are equal
         or if one of them is zero and gives 0 otherwise.

Usando o método na resposta da APL , obtemos a mesma contagem de bytes. Um byte a mais que essa resposta, porque o múltiplo comum mais baixo é de dois bytes.

6 bytes

«=æl×»

Experimente online!

— dylnan
fonte
Noto também um método alternativo abaixo
— H.PWiz
@ H.PWiz Oh, eu pensei que você estava usando o mesmo método como o de link
— dylnan
Eu dou dois métodos ∧=⌊e =*⌊. O segundo dos quais é preferido pela geléia
— H.PWiz
@ H.PWiz Eu não falo APL, estava apenas usando o método que você descreveu. O que =*⌊faz?
— Dylnan
É praticamente o mesmo que Jelly, exceto que ⌊é mínimo. Ou pode-se usar ×em ambas as línguas
— H.PWiz
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.