Figuras semelhantes
Dois retângulos são semelhantes se as proporções dos lados forem iguais.
Considere estes dois retângulos; um retângulo com 5 linhas de altura e 11 caracteres de largura:
===========
===========
===========
===========
===========
e um retângulo com 10 linhas de altura e 22 caracteres de largura:
======================
======================
======================
======================
======================
======================
======================
======================
======================
======================
Essas formas são semelhantes porque as proporções de seus lados são as mesmas. Para colocá-lo formalmente (com sendo o lado mais curto sendo o lado mais longo):
Você também pode fazer:
O desafio
Escreva um programa ou função que use um retângulo "principal" e alguns "outros" retângulos e imprima quais de "outros" são semelhantes a "principal".
A entrada
Uma forma e uma lista de formas. Cada forma consiste em 2 números inteiros positivos diferentes de zero, que indicam a largura e a altura do retângulo. Por exemplo, isto:
(4,2), (3,9)
denota dois retângulos, um 4x2 e um 3x9. O formato exato da entrada pode ser o que você desejar.
A saída
Os índices das "outras" formas que são semelhantes a "principal". Você pode escolher se os índices são baseados em 0 ou 1, bem como o formato e a ordem exatos da saída.
Programa de exemplo
Em Python:
main = eval(raw_input()) # The main rectangle.
rects = eval(raw_input()) # The list of rectangles.
similar = set()
for i, rect in enumerate(rects):
if max(main)*min(rect) == min(main)*max(rect): # Cross-multiply
# They are similar.
similar.add(i)
print similar
Entrada e saída de amostra
Entrada:
(1, 2)
[(1, 2), (2, 4)]
Saída:
set([0, 1])
Entrada:
(1, 2)
[(1, 9), (2, 5), (16, 8)]
Saída:
set([2])
Ganhando
Isso é código-golfe, então a submissão mais curta vence.
Notas
- Isso deve ser óbvio, mas as brechas padrão são proibidas .
- Nenhum componente interno para localizar figuras semelhantes pode ser usado. (Eu nem sei se isso existe, mas não ficaria surpreso!)
fonte
[1.0 2.0]
um formato de entrada aceitável?[(1,2), (2,4), (1,9), (2,5), (16,8)]
, é apenas[0,1,4]
e[1,2,5]
permitido, ou poderíamos também produzir[1,1,0,0,1]
ou[(1,2), (2,4), (16,8)]
?Respostas:
Pitão, 15 bytes
fonte
Python, 61 bytes
Sim, estou gastando 9 caracteres para escrever
enumerate
. Toma entrada como1, 2, [(1, 9), (3,6), (2, 5), (16, 8)]
. Para o Python 2, os valores de entrada precisam ser escritos como flutuadores.Um caractere a mais (62) no Python 3:
fonte
i
como índice e(x,y)
como ponto. Em seguida, verifica se o valorx/y
é igual ao quociente dos dois números iniciais (a/b
) ou recíproco (b/a
). Se for igual a um desses valores, esse valori
será adicionado à lista, caso contrário, será descartado.CJam,
222019 bytesA descrição acima é uma função anônima que exibe uma única matriz de pares de ponto flutuante (o primeiro par é agulha) da pilha e empurra a matriz de índices baseados em 1 em troca.
Experimente online no intérprete CJam .
Como funciona
fonte
Haskell , 48 bytes
Experimente online!
Chame isso como
(!) 1 2 [(1, 9), (3,6), (2, 5), (16, 8)]
.Uma porta próxima da minha resposta Python . A expressão
zip[0..]l
enumera a lista com seus índices.A expressão
x/y+y/x==a/b+b/a
verifica se a proporçãox/y
éa/b
oub/a
, uma vez que a funçãof(z) = z + 1/z
temf(z) = f(1/z)
e não outras colisões.fonte
h
um operador usando três argumentos? Isso economizaria um byte e acho que permaneceria dentro das regras.Boneco de neve 1.0.2 , 61 caracteres
Linguagem pura (a menos que você conheça o Snowman), ou seja, exatamente de acordo com o objetivo de design da linguagem de ser o mais confuso possível.
O formato de entrada é o mesmo da postagem, o formato de saída também é o mesmo menos
set(
e)
.Ungolfed (ou unminified, realmente):
Estou muito orgulhoso de alguns dos truques que usei neste:
Usei o mesmo formato de entrada do post. Mas, em vez de tentar analisá-lo de alguma forma, o que seria realmente confuso, eu apenas concatenou as duas linhas e, em seguida, usei um regex para extrair todos os números em uma grande matriz (com a qual eu fiz
2aG
, ou seja, obter todos os grupos de 2).:nD;aF
é bem chique. Ele simplesmente pega uma matriz de dois elementos e divide o primeiro pelo segundo. O que parece bastante simples, mas fazê-lo da maneira intuitiva (a[0]/a[1]
) seria muito, muito mais longo no Snowman:0aa`NiN`aA|,nD
(e isso pressupõe que não precisamos nos preocupar em mexer com outras variáveis existentes). Em vez disso, usei o método "fold" com um predicado de "divide", que, para uma matriz de dois elementos, alcança a mesma coisa.0AAgaA
parece bastante inócuo, mas o que realmente faz é armazenar0
a nas variáveis e, em seguida, leva todas as variáveis com um índice maior que isso (portanto, todas as variáveis, exceto a primeira). Mas o truque é que, em vez deAaG
(que se livraria da matriz original e da0
), eu useiAAg
, que mantém as duas. Agora eu usoaA
at-index, usando o mesmo0
para obter o primeiro elemento da matriz - além disso, ele está no modo de consumo (emaA
vez deaa
), para que ela se livre da0
matriz original e também, que agora são lixo para nos.Infelizmente,
0AAgaA*|
faz essencialmente a mesma coisa que GolfScript faz em um personagem:(
. No entanto, eu ainda acho que é muito bom, para os padrões do Snowman. :)fonte
Mathematica, 41 bytes
Uso:
fonte
Pitão - 14 bytes
Filtra comparando quocientes e depois mapeia
indexOf
.Conjunto de Teste .
fonte
1,2
e[(1, 2), (2, 4), (1, 2)]
dará[0, 1, 0]
mais do que o correto[0, 1, 2]
.APL (Dyalog Unicode) ,
1613 bytes SBCSExperimente online!
-3 graças a @ngn!
Explicação:
O formato de saída é um vetor binário como o
1 1 0 0 1
qual "outro" retângulo é semelhante.APL (Dyalog Extended) , 11 bytes SBCS
Experimente online!
Explicação:
O formato de saída é igual à resposta principal do Dyalog.
Agradecimentos a Adám pela ajuda no golfe + Extended.
fonte
(=.×∘⌽∨=.×)⍤1
Julia, 62 bytes
A
find
função localiza elementos verdadeiros em um vetor booleano..*
executa multiplicação elementar de vetores.Ungolfed:
Uso:
fonte
K5, 19 bytes
Eu acho que isso vai fazer o truque:
Leva uma lista de pares onde o primeiro é o "principal". Calcula a proporção, dividindo as dimensões classificadas de cada par. Retorna uma lista das posições indexadas em 0 dos pares correspondentes. (indiscutivelmente, o formato de entrada que escolhi torna este -1 indexado - se isso for considerado uma aderência inválida
1+
a no início e adicionar dois caracteres ao tamanho do meu programa.)Exemplo de uso:
Isso funciona em OK - note que eu implicitamente dependo da divisão sempre produzindo resultados de ponto flutuante. Funcionaria em Kona se você adicionasse um ponto decimal a todos os números na entrada e adicionasse um espaço após o
_
.fonte
Oitava / Matlab, 44 bytes
Usando uma função anônima:
O resultado está na indexação baseada em 1.
Para usá-lo, defina a função
e chame-o com o seguinte formato
Você pode experimentá-lo online .
Se o resultado puder estar na indexação lógica (
0
indica não semelhante,1
indica similar): 38 bytes :Mesmo exemplo que acima:
fonte
Braquilog , 14 bytes
Experimente online!
Recebe a entrada como uma lista que contém uma lista que contém o retângulo principal e a lista de outros retângulos (como é o caso de teste 1
[[[1,2]],[[1,2],[2,4]]]
) e gera uma lista de índices baseados em 0 através da variável de saída.Se esse tipo de formatação de entrada ímpar e específica está trapaceando, é um pouco mais longo ...
Braquilog , 18 bytes
Experimente online!
Recebe a entrada como uma lista que contém o retângulo principal e a lista de outros retângulos (para que o caso de teste 1 seja o mais óbvio
[[1,2],[[1,2],[2,4]]]
) e gera uma lista de índices baseados em 0 através da variável de saída.Para determinar se dois pares largura-altura representam retângulos semelhantes, são necessários apenas quatro bytes
pᵐ/ᵛ
(que gera a taxa compartilhada ou sua recíproca). Todo o resto está lidando com os vários retângulos a serem comparados e a saída sendo índices.fonte
dzaima / APL , 7 bytes
Experimente online!
8 bytes emitindo uma lista de índices em vez de um vetor booleano
fonte
[0,1,4]
ou[1,2,5]
(não tenho certeza se o seu idioma é indexado em 0 ou 1). Teria sido um desafio melhor se todos os três formatos de saída fossem permitidos: índices; filtro para manter os valores de verdade; lista de valores truthy / falsey (como você tem agora), em vez de apenas índices permitidos.[0,1,4]
,[1,2,5]
,4\n0\n1
,5 2 1
, etc., etc., uma vez que ainda afirmou índices . Mas pedi ao OP para esclarecer (se eles responderem, já que é um desafio de 4 anos). Na minha resposta 05AB1E, significaria 14 bytes se os índices forem obrigatórios vs 8 bytes, se uma das outras duas opções for permitida. Independentemente disso, votei na sua resposta. :)Haskell, 75 bytes
fonte
PowerShell , 57 bytes
Experimente online!
Os índices são baseados em 1.
fonte
PowerShell ,
5856 bytes-2 bytes graças ao mazzy x2
Experimente online!
Isso abusa um pouco da
input may be however you desire
cláusula ao fazer com que os componentes da primeira forma sejam separados separadamente para salvar 3 bytes.PowerShell ,
6159 bytesExperimente online!
Usa a indexação condicional para alternar entre o índice atual baseado em zero e o nulo, com base na alinhação ou não das proporções. Felizmente, neste caso, é
$i
incrementado independentemente de sua impressão ou não.fonte
-
vez-ne
.Javascript (ES6), 75
Alternativa, também 75
A entrada é tomada como um objeto JSON e uma matriz de objetos JSON
fonte
05AB1E ,
1514 bytesExperimente online ou verifique todos os casos de teste .
Explicação:
o
J
entradas estão lá porque 05AB1E não pode determinar os índices nas listas multidimensionaisSe estiver produzindo os pares largura / altura que são verdadeiros ou se estiver produzindo uma lista de valores de verdade / falsey com base na lista de entrada, pode haver 8 bytes :
Experimente online ou verifique todos os casos de teste .
Experimente online ou verifique todos os casos de teste .
fonte