Um "número de Gizé", também conhecido coloquialmente como um número Timmy, é qualquer número em que os dígitos representem uma pirâmide ( A134810 ). Por exemplo, "12321" é um número de gizé porque pode ser visualizado da seguinte maneira:
3
2 2
1 1
No entanto, algo como "123321" não é um número de Gizé porque existem dois dígitos no topo da pirâmide
33
2 2
1 1
Em outras palavras, um número é um número de Gizé se todas as seguintes condições forem atendidas:
Tem um número ímpar de dígitos, e o dígito central é o maior
É palíndrico (a mesma leitura para frente ou para trás) e
A primeira metade dos dígitos está aumentando estritamente em um. (Como deve ser palíndrico, isso significa que a segunda metade dos dígitos deve diminuir estritamente em um)
Você deve escrever um programa completo ou uma função que use um número inteiro positivo como entrada e determinar se é um número de Gizé ou não. Você pode considerar a entrada como uma sequência ou como um número. Se for um número de Gizé, produza um valor de verdade . Caso contrário, um valor falso.
Há um total de 45 números de Gizé, portanto, qualquer uma dessas entradas deve resultar em um valor verdadeiro:
1
2
3
4
5
6
7
8
9
121
232
343
454
565
676
787
898
12321
23432
34543
45654
56765
67876
78987
1234321
2345432
3456543
4567654
5678765
6789876
123454321
234565432
345676543
456787654
567898765
12345654321
23456765432
34567876543
45678987654
1234567654321
2345678765432
3456789876543
123456787654321
234567898765432
12345678987654321
Qualquer outra entrada deve fornecer um valor falso. Obviamente, você não precisa lidar com entradas inválidas, como números não positivos, números inteiros ou números não.
Como de costume, isso é código-golfe , então as brechas padrão são proibidas e a resposta mais curta em bytes vence!
fonte
Respostas:
Python 2,
484746 bytesTeste em Ideone .
Como funciona
No Python, uma comparação encadeada retorna True se e somente se todas as comparações individuais fizerem o mesmo. Nesse caso específico, nosso lambda retorna True se e somente se todas as seguintes condições forem atendidas.
s[~len(s)/2:]in'987654321'
Para uma sequência s de comprimento 2n + 1 ,
~len(s)/2
retorna ~ (2n + 1) / 2 = - (2n + 2) / 2 = - (n + 1) , portanto,s[~len(s)/2:]
gera os n + 1 caracteres mais à direita de s .Da mesma forma, para uma sequência s de comprimento 2n ,
~len(s)/2
retorna ~ (2n) / 2 = - (2n + 1) / 2 = - (n + 1) (a divisão inteira sempre é arredondada para -∞ , portantos[~len(s)/2:]
, mais uma vez, produz o n + mais à direita 1 caracteres de sA comparação retornará True se e somente se os caracteres n + 1 mais à direita formarem uma substring de
987654321
.Note-se que se o fizerem e s tem 2n personagens, s não pode ser um palíndromo; o n th e (n + 1) th caracteres a partir da direita vai ser diferente, e o último é o n ° de caracteres a partir da esquerda.
'987654321'>s
Isso compara as strings lexicograficamente. Como 9 é o único número de Gizé que começa com 9 , todos os números de Gizé satisfazem essa comparação.
Observe que comparar essas cadeias não faz parte do nosso problema de decisão;
>s
é simplesmente três caracteres menor queand s
.s==s[::-1]
Isso retorna True se e somente se s for um palíndromo.
fonte
Perl,
39374239 + 1 = 40 bytesUsando um novo método, consegui reduzir um grande número de bytes. Corra com a
-n
bandeira. Aceita entrada repetidamente em tempo de execução, imprimindo 0 ou 1 de acordo.Eu tive que adicionar 5 bytes porque percebi que sem ele, o código funcionava para entradas como 1234567900987654321, que não é um número de Gizé. Como os números de Gizé nunca contêm o dígito 0 (e todos os falsos positivos, por necessidade, conteriam o dígito 0), esses 5 bytes são responsáveis por isso.
Explicação:
O objetivo do regex de substituição é construir uma sequência de 1s cujo comprimento seja metade do comprimento da entrada, arredondada para cima. Assim, uma entrada de
12321
produzirá a string111
, que será quadrada (explicação abaixo). Entradas uniformes produzirão seqüências de caracteres muito pequenas para garantir que o regex final seja bem-sucedido.O motivo desse código funcionar é o seguinte:
Podemos ver claramente que o número de 1s no RHS é igual a 1/2 mais da metade do tamanho do LHS. (Mais 1 se truncarmos). Além disso:
567898765 - 123454321 = 444444444, que tem apenas 4 repetições. Portanto, quando subtraímos nosso quadrado do nosso número, se obtivermos um re-dígito, nosso número original é um número de Gizé.
Código antigo e método antigo (58 + 1 = 59 bytes)
Guardado 1 byte graças a @Dada
Execute com a
-n
bandeira, canalize o texto usandoecho
Calcula o número único de gizé determinado pelo comprimento e pelo número inteiro inicial e verifica se ele corresponde à entrada.
Executar como
echo -n "123454321" | perl -M5.010 -n giza.pl
Retorna1
se for um número de Gizé, caso contrário, nulo.fonte
Geléia ,
1076 bytesGera todos os 45 números de números de Gizé e depois testa a associação.
Experimente online! ou veja os números gerados .
Como funciona
fonte
JavaScript (ES6),
46454241 bytesPega a entrada como uma sequência e retorna uma sequência de um dígito
0
para verdade , para falsidade.A idéia básica é verificar algumas coisas:
fonte
Java 7,
128 119105 bytesSem mais cordas! Então, agora começo gerando um
111...
número do mesmo comprimento que input (a
) e um menor para o quadrado (b
). Em seguida, você pode subtrairb*b
da entrada e verificar a divisibilidade pora
.c
está lá para checar ímpares / pares, não importa> _>Espaços em branco:
Método antigo, 119 bytes
Percorre a matriz, verificando a diferença de 1 (ou -1, dependendo da metade) entre cada dígito. Em seguida, basta verificar se o comprimento é ímpar.
Espaços em branco:
fonte
char[]
conta como uma string aqui, então eu diria que é válida.05AB1E ,
98 bytesVerdade é 1 , falso é 0 .
Usa a codificação CP-1252 . Experimente online!
fonte
2ä¬û¹Q
isso funcionaria bem e economiza dois bytes.Python 2,
77, 76, 64, 63 bytesUma solução recursiva simples. Verifica se o primeiro e o último dígito são iguais e o segundo dígito menos um. Em seguida, verifica se o meio também é um número de Gizé. Retorna true quando se reduz a um único dígito.
Um byte economizado graças ao @Rod, uma tonelada de bytes salvos graças ao DLosc e ETHProductions!
fonte
len(s)==1
com1==len(s)
para economizar 1 byte no espaço, também, osand
s podem ser substituídos por*
para economizar 3 bytes #1or
funciona também. (Contanto que não é um0
precedente doo
Python --então acha que é um número octal.)and
com*
quando o comportamento de curto-circuito é necessária, como é em uma função recursiva. O primeiroand
deve ser substituível, mas precisa de dois conjuntos de parênteses, o que nega qualquer economia. (cc: @Rod)int()
voltas[0]
ou 2) o usos[0]==`int(s[1])-1`
?s[-1]==s[0]==`int(s[1])-1`
(requer o Python 2 especificamente).PowerShell v3 +,
14710867 bytesAbordagem radicalmente alterada. Gera todos os números possíveis de Gizé e depois verifica se a entrada
$args[0]
é-in
essa coleção. Abaixo está como a coleção de números de Gizé é formada:Exemplo é executado:
fonte
Python 3, 65 bytes
Não tenho muita certeza, mas acho que isso funciona.
fonte
0
, você pode removê-lo :) Também não haverá números maiores que 17 que satisfaçam essa condição, portanto você também não precisa disso. É essencialmente a mesma solução Dennis tem :)Python 2,
687366 bytesabusando do fato de que
11^2=121
,111^2=12321
e assim por diante, eu calculo isso e adiciono1111..
tempos suficientes como deslocamento.Exemplos:
23432=111^2+11111*1
676=11^2+111*5
fonte
f
, não precisa nomeá-lo. Você pode salvar dois bytes removendof=
1234567900987654321
retorna true, quando deveria ser falsa.Perl, 41 bytes
40 bytes de código +
-p
sinalizadores.Saídas 1 se a entrada for um número de Gizé, nada caso contrário. Forneça a entrada sem nova linha final para executá-la:
Explicações : primeiro,
s/(.)(?=(.))/$1-$2/ge
substitua cada dígito$1
(seguido por$2
) por$1-$2
. Se for um número de Gizé, então cada dígito será um a menos do que o próximo no início e mais um no final, a sequência deverá conter apenas-1
na primeira parte e1
na segunda (exceto a última que permanece inalterada) . É isso que a segunda parte/^(-1(?1)1|).$/
verifica: procura por um-1
seguido de recursão seguido por a1
.-1 byte graças a Martin Ender.
Minha versão anterior 15 bytes mais longa (bem diferente, então deixarei aqui):
fonte
|
segundo regex.> <> PEIXES
57524948 bytesEdit 1: = retorna 0 ou 1 se true, então removeu uma verificação e usou esse valor para incrementar; depois, verifica a igualdade depois de qualquer maneira. (salvou 6 bytes, perdeu 1 para a nova linha).
Edite os marcadores direcionais 2: 3 removidos e 11 colocados no espaço para deslocar a pilha até um comprimento uniforme para forçar falso (3 bytes salvos).,
Edit 3: Duplique o comprimento da pilha para verificar MOD por 2 e len (1), isso foi feito colocando o comprimento duas vezes antes, mas agora preenchia um espaço vazio na linha 2 (1 byte salvo).
fonte
C #,
1208610810292 bytesPrograma completo com alguns casos de teste:
Viva as condições condicionais de linha única, agora superando a resposta Java :)! Também escrevi meus primeiros comentários explicativos, embora provavelmente seja auto-explicativo. Agradeço a @Dada por encontrar um problema com meu algoritmo (era verdade para números espelhados como 13631). Agora, sub 100, pois aparentemente a verificação do comprimento% 2 é redundante.
fonte
true
para números como13631
? Além disso, desde que você faz uma chamada recursivax
, acho que precisa incluirx=
na sua contagem de bytes.Bash, 111 bytes
ATUALIZAR
Observe que a normalização do número de entrada provavelmente pode ser ignorada completamente, se você apenas adicionar o primeiro dígito de volta ao seu número GIZA gerado , assim:
e então basta compará-lo com a entrada diretamente.
Isenção de responsabilidade: este não é realmente otimizado, por isso é mais uma prova de conceito do que um candidato real
Golfe
Algoritmo
Qualquer número GIZA pode ser normalizado para sua forma canônica, subtraindo o primeiro dígito do resto:
e existe apenas um número canônico da GIZA de um comprimento específico.
Sabendo disso, podemos gerar facilmente um número GIZA canônico com base no comprimento do número de entrada:
normalize o número de entrada:
e compare
Teste
fonte
Na verdade , 22 bytes
Experimente online!
Recebe a entrada como uma string entre aspas (por exemplo
"12321"
). A saída é um número inteiro positivo para verdadeiro e0
para falso.Explicação:
fonte
Haskell, 62 bytes
A entrada é tomada como uma sequência.
Cria uma lista de todos os números de Gizé e verifica se o número está nele. A lista é criada por looping
i
através de'1'..'9'
e, em seguida,j
através de'1'..i
e criando os elementosj .. i-1 , i , i-1 .. j
.fonte
> <> , 62 bytes
Experimente online!
Saídas 1 para um número de Gizé; 0 caso contrário. Funciona empurrando a entrada para uma desenfileiramento (ok, tecnicamente uma pilha reversível) e testando repetidamente as duas extremidades quanto à igualdade, além de garantir que elas sejam exatamente uma maior que o valor anterior.
fonte
CJam ,
2019 bytesSuíte de teste.
Explicação
A idéia básica é encontrar o dígito mínimo e máximo, criar um número de Giza a partir deles e verificar se é equivalente à entrada.
Em vez do caractere mínimo, também podemos usar o primeiro caractere, para a mesma contagem de bytes:
fonte
Mathematica,
626160 bytes2 bytes salvos devido a @MartinEnder .
Composição de funções. Pega um número como entrada e retorna
True
ouFalse
como saída.fonte
Retina,
555436 bytesA contagem de bytes assume a codificação ISO 8859-1.
Experimente online
Converta cada dígito em unário, separado por dois pontos. Loop, removendo dígitos externos correspondentes se o próximo dígito for mais um. Corresponde a um único dígito restante.
fonte
12312
PHP, 71 bytes
busca o maior dígito da entrada e faz a contagem regressiva, adicionando o novo dígito a uma sequência de comparação até que a sequência de entrada e comparação seja igual - ou
$i
seja0
.imprime o dígito mais baixo para um número Timmy, caso
0
contrário.fonte
Pushy ,
3015 bytesAcordei esta manhã e percebi que podia metade da duração da minha resposta ...
(não concorrente como o idioma pós-desafio)
A entrada é dado na linha de comando:
$ pushy gizas.pshy 3456543
. Saídas1
para verdade e0
falsidade. Aqui está o detalhamento:O algoritmo foi inspirado na resposta do bash: primeiro, normalize o número (
45654 -> 01210
), gere o número de giza normalizado do mesmo tamanho (existe apenas um) e compare.Solução antiga
fonte
Raquete 292 bytes
Ungolfed:
Teste:
Saída:
fonte
Java 8, 162 + 19 bytes
19 para
import java.util.*;
Abordagem diferente da outra resposta Java, eu queria tentar usar o método de criar todos os números Timmy possíveis e verificar se nossa string estava contida neles.
fonte
Oitava, 56 bytes
Confira todos os casos de teste aqui .
Seriam dois bytes a menos no MATLAB, pois
diff(n)
funciona para strings. No Octave, você precisadiff(+n)
.Explicação:
fonte
Mathematica, 56 bytes
Isso é um pouco mais curto:
fonte
Java 7,
129 119109 bytesAntigo método recursivo, 119
-10 bytes graças ao Geobits. Nós
sãoforam amarrados ...Experimente online!
fonte
and
, acho que você usou uma vez, mas não na outra vez? Ou estou lendo errado.java.util.Arrays.copyOfRange(...)
para ignorar a linha de importação.Perl 6 ,
4334 bytesAgradecimentos a Jo King por -9 bytes.
Solução Perl do porto de Gabriel Benamy .
Experimente online!
fonte
Cjam, 35 bytes
Provavelmente muito abaixo do ideal ... Estou um pouco sem prática!
Experimente online!
fonte
Python 2,
50828180 bytesAbordagem simples. Apenas divide a cadeia ao meio (perdendo o caractere do meio ou um após o caractere do meio, se tiver comprimento uniforme), inverte a segunda metade e depois compara as duas e compara a primeira metade com uma sequência de 1 a 9.
Editar
Reeditado após feedback construtivo de outros jogadores e percebendo e corrigindo meus erros.
-1 por perder um (desperdício de) espaço
-1 por ler a pergunta novamente e perceber que não precisamos levar 0 em consideração. Realmente deve parar de jogar golfe depois de um longo dia de trabalho.
fonte
13531
e6543456
ambos retornam incorretamente True.'0'
e'1'
são verdadeiras.