Bens Giza Golf!

41

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 é , então as brechas padrão são proibidas e a resposta mais curta em bytes vence!

DJMcMayhem
fonte
e quanto a 0? isso é verdade?
Tuskiomi
@tuskiomi Tecnicamente, não, mas é irrelevante porque você não precisa lidar com números não positivos.
DJMcMayhem
11
A razão pela qual pergunto é porque, se for um número de Gizé, números como 1210, 123210 etc. também seriam verdadeiros.
Tuskiomi 16/11/16
5
@tuskiomi Nenhum deles é palindrômico ou possui um número ímpar de dígitos. A menos que você esteja contando um 0 à esquerda, mas isso torna tudo muito mais complicado.
DJMcMayhem
11
@ nedla2004 Acho que os 0 principais tornam os formatos de entrada mais complicados. Para manter tudo agradável e simples, diremos que você pode assumir que as entradas não conterão 0's iniciais.
DJMcMayhem

Respostas:

30

Python 2, 48 47 46 bytes

lambda s:s[~len(s)/2:]in'987654321'>s==s[::-1]

Teste 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)/2retorna ~ (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)/2retorna ~ (2n) / 2 = - (2n + 1) / 2 = - (n + 1) (a divisão inteira sempre é arredondada para -∞ , portanto s[~len(s)/2:], mais uma vez, produz o n + mais à direita 1 caracteres de s

    A 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 que and s.

  • s==s[::-1]

    Isso retorna True se e somente se s for um palíndromo.

Dennis
fonte
8
Essa resposta é uma magia insana. Entendo como partes dele funcionam, mas não consigo nem entender como você o criou. E, por um momento, fiquei orgulhoso dos meus 64 anos. +1
DJMcMayhem
2
eu amo a comparação garantido para salvar essas 3 bytes
greyShift
22

Perl, 39 37 42 39 + 1 = 40 bytes

Usando um novo método, consegui reduzir um grande número de bytes. Corra com a -nbandeira. 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.

say!/0/*($_- s/..?/1/gr**2)=~/^(.)\1*$/

Explicação:

say!/0/*($_- s/..?/1/gr**2)=~/^(.)\1*$/  #$_ contains input by default.
   !/0/                                  #Ensure that the initial text doesn't contain the number 0
       *                                 #Since both halves of this line return either 0 or 1, multiplying them together only yields 1 if both are true (which we want).
             s/   / /gr                  #Perform a substitution regex on $_ (see below)
                                         #/g means keep replacing, /r means don't modify original string; return the result instead
               ..?                       #Replace 1 or 2 characters (2, if possible)...
                   1                     #...with the number 1
                       **2               #Square this number...
        ($_-              )              #...and subtract it from the input
                           =~            #Do a regex match on the result
                             /^      $/  #Make sure the regex matches the WHOLE string
                               (.)       #Match any character...
                                  \1*    #...followed by itself 0 or more times
say                                      #Finally, output the result of the whole line of code.

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 12321produzirá a string 111, 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:

        1         =         1**2
       121        =        11**2
      12321       =       111**2
     1234321      =      1111**2
    123454321     =     11111**2
   12345654321    =    111111**2
  1234567654321   =   1111111**2
 123456787654321  =  11111111**2
12345678987654321 = 111111111**2

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 -nbandeira, canalize o texto usandoecho

say$_==($;=join"",/(.)/..($==y///c/2+/(.)/)-1).$=.reverse$

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 Retorna 1se for um número de Gizé, caso contrário, nulo.

Gabriel Benamy
fonte
2
Essa é uma bela observação para o segundo método.
Trichoplax
15

Geléia , 10 7 6 bytes

9ẆŒBḌċ

Gera 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

9ẆŒBḌċ  Main link. Argument: n

9       Set the return value to 9.
 Ẇ      Windows; yield all "substrings" of [1, ..., 9].
  ŒB    Bounce; map each [a, ..., b] to [a, ..., b, ..., a].
    Ḍ   Undecimal; convert the digit arrays to integers.
     ċ  Count the number of occurrences of n.
Dennis
fonte
10

JavaScript (ES6), 46 45 42 41 bytes

f=([c,...s])=>s+s&&c-s.pop()|c-~-f(s)?0:c

Pega a entrada como uma sequência e retorna uma sequência de um dígito 0para verdade , para falsidade.

A idéia básica é verificar algumas coisas:

  • Se a string tiver um caractere, OU
  • o primeiro caractere é o mesmo que o último caractere e
  • a seção do meio também é um número de Gizé e
  • o segundo caractere é um a mais que o primeiro caractere aqui.
ETHproductions
fonte
Desculpe, eu interpretei mal a pergunta.
Neil
10

Java 7, 128 119 105 bytes

boolean t(long n){long a=1,b=1,c=0;for(;a<n/10;b=b*b<=n/10?b*10+1:b,c^=1)a=a*10+1;return(n-b*b)%a<1&c<1;}

Sem 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 subtrair b*bda entrada e verificar a divisibilidade por a. cestá lá para checar ímpares / pares, não importa> _>

Espaços em branco:

boolean t(long n){
    long a=1,b=1,c=0;
    for(;a<n/10;b=b*b<=n/10?b*10+1:b,c^=1)
        a=a*10+1;
    return(n-b*b)%a<1&c<1;
}

Método antigo, 119 bytes

boolean g(char[]a){int i=1,l=a.length,b=1,d;for(;i<l;b*=i++>l/2?d==-1?1:0:d==1?1:0)d=a[i]-a[i-1];return b>0?l%2>0:0>1;}

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:

boolean g(char[]a){
    int i=1,l=a.length,b=1,d;
    for(;i<l;b*=i++>l/2?d==-1?1:0:d==1?1:0)
        d=a[i]-a[i-1];
    return b>0?l%2>0:0>1;
}
Geobits
fonte
Por que você precisa verificar se o primeiro é o mesmo que o último?
Nathan Merrill
3
Não faço idéia do que você quer dizer> _>
Geobits
Esta é uma resposta válida, considerando que o problema especifica que a função deve receber um número inteiro positivo? É claro que uma matriz de caracteres pode representar um número inteiro positivo, mas acho que é uma distinção importante.
Hypino
11
@Hypino O problema diz que a entrada pode ser tomada como uma string ou número inteiro e char[] conta como uma string aqui, então eu diria que é válida.
Geobits
@ Geobits Ah, eu senti falta da parte em que dizia que poderia ser tomada como uma String.
Hypino #
6

05AB1E , 9 8 bytes

Verdade é 1 , falso é 0 .

9LŒ€ûJ¹å

Usa a codificação CP-1252 . Experimente online!

Adnan
fonte
Eu acho que 2ä¬û¹Qisso funcionaria bem e economiza dois bytes.
Osable
O @Osable 12521 não é um número de Gizé, isso falha no elemento do meio.
Magic Octopus Urn
Percebo agora que pulei o terceiro ponto (dígitos consecutivos). Deixa pra lá!
Osable
Ahhhh ... Eu estava usando prefixos, vou manter os substrings em mente para esforços futuros, um pequeno truque.
Magic Octopus Urn
6

Python 2, 77, 76, 64 , 63 bytes

f=lambda s:2>len(s)or(s[0]==s[-1]==`int(s[1])-1`and f(s[1:-1]))

Uma 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!

DJMcMayhem
fonte
você pode trocar len(s)==1com 1==len(s)para economizar 1 byte no espaço, também, os ands podem ser substituídos por *para economizar 3 bytes #
Rod Rod
Apenas para adicionar ao comentário de Rod: 1orfunciona também. (Contanto que não é um 0precedente do oPython --então acha que é um número octal.)
DLosc
11
Você geralmente não pode substituir andcom *quando o comportamento de curto-circuito é necessária, como é em uma função recursiva. O primeiro anddeve ser substituível, mas precisa de dois conjuntos de parênteses, o que nega qualquer economia. (cc: @Rod)
DLosc
11
Eu não sei muito Python, mas você 1) poderia remover a int()volta s[0]ou 2) o uso s[0]==`int(s[1])-1` ?
ETHproductions
11
Com base na sugestão do @ETHproductions: s[-1]==s[0]==`int(s[1])-1`(requer o Python 2 especificamente).
DLosc
6

PowerShell v3 +, 147 108 67 bytes

$args[0]-in(1..9+(1..8|%{$i=$_;++$_..9|%{-join($i..$_+--$_..$i)}}))

Abordagem radicalmente alterada. Gera todos os números possíveis de Gizé e depois verifica se a entrada $args[0]é -inessa coleção. Abaixo está como a coleção de números de Gizé é formada:

1..9+(1..8|%{$i=$_;++$_..9|%{-join($i..$_+--$_..$i)}})
      1..8|%{                                       }  # Loop from 1 up to 8
             $i=$_;                                    # Set $i to the current number
                   ++$_..9|%{                      }   # Loop from one higher up to 9
                                   $i..$_+--$_..$i     # Build two ranges and concatenate
                                                       # E.g., 2..5 + 4..2
                             -join(               )    # Join into a single string
1..9+(                                               ) # Array concatenate with 1 to 9

Exemplo é executado:

PS C:\Tools\Scripts\golfing> 12321,5678765,121,4,123321,1232,5678,13631|%{"$_ --> "+(.\giza-numbers.ps1 "$_")}
12321 --> True
5678765 --> True
121 --> True
4 --> True
123321 --> False
1232 --> False
5678 --> False
13631 --> False
AdmBorkBork
fonte
108 -> 67 ... parece que você venceu desta vez (e provavelmente a maior parte do tempo): P
Yodle 17/11
5

Python 3, 65 bytes

lambda x:len(x)<18and x[:len(x)//2+1]in'0123456789'and x[::-1]==x

Não tenho muita certeza, mas acho que isso funciona.

0WJYxW9FMN
fonte
11
Não há números de Gizé que começam com 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 :)
Kade
@ Shebang, mas este foi publicado primeiro ... #
Rod #
@Rod eu não estava afirmando que ele copiou ou qualquer coisa :)
Kade
@Shebang Nem sou eu:
Rod
5

Python 2, 68 73 66 bytes

lambda n:n==`int('1'+len(n)/2%9*'1')**2+int(len(n)*`int(n[0])-1`)`

abusando do fato de que 11^2=121, 111^2=12321e assim por diante, eu calculo isso e adiciono 1111..tempos suficientes como deslocamento.
Exemplos:
23432=111^2+11111*1
676=11^2+111*5

Cajado
fonte
Como você não está ligando f, não precisa nomeá-lo. Você pode salvar dois bytes removendof=
DJMcMayhem
Você deve definir um limite para isso. A entrada 1234567900987654321retorna true, quando deveria ser falsa.
Geobits
@Geobits ooops, fixado (eu acho?) #
Rod Rod
4

Perl, 41 bytes

40 bytes de código + -psinalizadores.

s/(.)(?=(.))/$1-$2/ge;$_=/^(-1(?1)1|).$/

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:

echo -n '123456787654321' | perl -pe 's/(.)(?=(.))/$1-$2/ge;$_=/^(-1(?1)1|).$/'

Explicações : primeiro, s/(.)(?=(.))/$1-$2/gesubstitua 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 -1na primeira parte e 1na segunda (exceto a última que permanece inalterada) . É isso que a segunda parte /^(-1(?1)1|).$/verifica: procura por um -1seguido de recursão seguido por a 1.

-1 byte graças a Martin Ender.


Minha versão anterior 15 bytes mais longa (bem diferente, então deixarei aqui):

echo -n '123456787654321' | perl -F -pe '$\=$_ eq reverse;$\&=$F[$_-1]+1==$F[$_]for 1..@F/2}{'
dada
fonte
A única parte disso que não entendo é o objetivo do |segundo regex.
Gabriel Benamy
@GabrielBenamy Esse é o caso base do bloco recursivo (ou seja, ele não corresponde a nada e interrompe a recursão).
Dada
3

> <> PEIXES 57 52 49 48 bytes

i:1+?!vi00.;n1<
%?v0n;>~l:1-?!^2
{:<11 ^?:=@:$+=

Edit 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).

Pelicano-verde
fonte
3

C #, 120 86 108 102 92 bytes

x=I=>{var Z=I.Length;return Z<2?1>0:I[0]==I[Z-1]&I[1]-0==I[0]+1?x(I.Substring(1,Z-2)):0>1;};

Programa completo com alguns casos de teste:

class a
{
    static void Main()
    {
        Func<string, bool> x = null;

        x = I=>
        {
            var Z=I.Length;
            return Z==1?                           // length == 1?
                     1>0:                          // return true (middle of #)
                     I[0]==I[Z-1]&I[1]-0==I[0]+1?  // else start == end and the next number is 1 above the current?
                       x(I.Substring(1,Z-2)):      // recursive call on middle
                       0>1;                        // else false
        };

        Console.WriteLine("1 -> " + (x("1") == true));
        Console.WriteLine("9 -> " + (x("9") == true));
        Console.WriteLine("121 -> " + (x("121") == true));
        Console.WriteLine("12321 -> " + (x("12321") == true));
        Console.WriteLine("4567654 -> " + (x("4567654") == true));
        Console.WriteLine("12345678987654321 -> " + (x("12345678987654321") == true));
        Console.WriteLine("12 -> " + (x("12") == false));
        Console.WriteLine("1221 -> " + (x("1221") == false));
        Console.WriteLine("16436346 -> " + (x("16436346") == false));
        Console.WriteLine("123321 -> " + (x("123321") == false));
        Console.WriteLine("3454321 -> " + (x("3454321") == false));
        Console.WriteLine("13631 -> " + (x("13631") == false));
        Console.WriteLine("191 -> " + (x("13631") == false));
        Console.Read(); // For Visual Studio
    }
}

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.

Yodle
fonte
11
Isso não retornaria truepara números como 13631? Além disso, desde que você faz uma chamada recursiva x, acho que precisa incluir x=na sua contagem de bytes.
Dada
@ Dadá Heh bom ponto, sabia que estava faltando alguma coisa ... E tudo bem, vou adicioná-los à contagem.
Yodle
Espere, você está batendo o que agora? ;)
Geobits
@Geobits Dangit! Verei o que posso fazer amanhã: P
Yodle 17/11
3

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:

01210 + 6 => 67876

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

G() { I=`sed "s/./\0-${1::1}\n/g"<<<$1|bc`;Z=`seq 0 $((${#1}/2))`;A=`rev <<<$Z`;cmp -s <(echo $I) <<<$Z${A:1}

Algoritmo

Qualquer número GIZA pode ser normalizado para sua forma canônica, subtraindo o primeiro dígito do resto:

67876 - 6 => 01210
78987 - 7 => 01210

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:

 Z=`seq 0 $((${#1}/2))`;A=`rev <<<$Z` => $Z${A:1}

normalize o número de entrada:

 I=`sed "s/./\0-${1::1}\n/g"<<<$1|bc`

e compare

 cmp -s <(echo $I) <<<$Z${A:1};

Teste

for i in `seq 0 1000`; do G $i && echo $i; done

0
1
2
3
4
5
6
7
8
9    
121
232
343
454
565
676
787
898

...

G 12345678987654321 && echo "OK" || echo FALSE     
OK

G 123456789987654321 && echo "OK" || echo FALSE
FALSE
zepelim
fonte
Eu espero que você não se importa, eu implementei uma parte deste algoritmo em minha resposta :)
FlipTack
1

Na verdade , 22 bytes

9uR;∙`xR;RdX+εj`M;░#íu

Experimente online!

Recebe a entrada como uma string entre aspas (por exemplo "12321"). A saída é um número inteiro positivo para verdadeiro e 0para falso.

Explicação:

9uR;∙`xR;RdX+εj`M;░#íu
9uR;∙                   cartesian product of [1,2,3,4,5,6,7,8,9,10] with itself
     `xR;RdX+εj`M       for each pair:
      x                   construct the half-open (end-exclusive) range ([1, 5] -> [1, 2, 3, 4])
       R                  reverse
        ;RdX+             duplicate, reverse, remove first element, prepend ([1, 2, 3, 4] -> [1, 2, 3, 4, 3, 2, 1])
             εj           concatenate into a string
                 ;░     filter out empty strings
                   #íu  test for membership
Mego
fonte
1

Haskell, 62 bytes

(`elem`[[j..pred i]++[i,pred i..j]|i<-['1'..'9'],j<-['1'..i]])

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 iatravés de '1'..'9'e, em seguida, jatravés de '1'..ie criando os elementos j .. i-1 , i , i-1 .. j.

nimi
fonte
1

> <> , 62 bytes

i:0(   ?v
v!1&!~{!<:=$:@&-1=+2=*>l!-3!1(!:?
>l!;2!n=!0?!<-1=n;

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.

Brian Gradin
fonte
1

CJam , 20 19 bytes

l_$_W=),\ci>_W<W%+=

Suí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.

l       e# Read input.
_$      e# Get a sorted copy of the input.
_W=     e# Get its last character, i.e. the maximum digit M.
),      e# Get a string with all characters from the null byte up to M.
\c      e# Get the first character of the sorted string, i.e. the minimum
        e# character m.
i>      e# Convert to its character code and discard that many leading
        e# characters from the string we generated before. Now we've got
        e# a string with all digits from m to M, inclusive.
_W<W%+  e# Palindromise it, by appending a reversed copy without M.
=       e# Check that it's equal to the input.

Em vez do caractere mínimo, também podemos usar o primeiro caractere, para a mesma contagem de bytes:

l_:e>),1$ci>_W<W%+=
Martin Ender
fonte
1

Mathematica, 62 61 60 bytes

2 bytes salvos devido a @MartinEnder .

MatchQ[{a:1...,b___}/;{b}==-{a}]@*Differences@*IntegerDigits

Composição de funções. Pega um número como entrada e retorna Trueou Falsecomo saída.

LegionMammal978
fonte
1

Retina, 55 54 36 bytes

A contagem de bytes assume a codificação ISO 8859-1.

.
$*1:
+`^(1+:)(1\1.*)\b\1$
$2
^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.

mbomb007
fonte
11
Isto aceita12312
Martin Ender
1

PHP, 71 bytes

for($t=$i=max(str_split($s=$argv[1]));$t!=$s&&--$i;)$t="$i$t$i";echo$i;

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 $iseja 0.

imprime o dígito mais baixo para um número Timmy, caso 0contrário.

Titus
fonte
1

Pushy , 30 15 bytes

Acordei esta manhã e percebi que podia metade da duração da minha resposta ...

s&K-kL2/OvhXwx#

(não concorrente como o idioma pós-desafio)

A entrada é dado na linha de comando: $ pushy gizas.pshy 3456543. Saídas 1para verdade e 0falsidade. Aqui está o detalhamento:

s                  % Split the number into its individual digits
 &K-               % Subtract all digits by the last 
    kL2/  h        % Get the halved length of the stack (+1)
        Ov X       % In stack 2, generate range (0, halved length)
            w      % Mirror the range 
             x#    % Check stack equality and output

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

s&K-Y?kL2%?L2/:.;&OvhXx#i;;;0#
FlipTack
fonte
1

Raquete 292 bytes

(let*((s(number->string n))(sn string->number)(st string)(lr list-ref)(sl(string->list s))(g(λ(i)(-(sn(st(lr sl(add1 i))))
(sn(st(lr sl i)))))))(cond[(even?(string-length s))#f][(not(equal? s(list->string(reverse sl))))#f][(andmap identity
(for/list((i(floor(/(length sl)2))))(= 1(g i))))]))

Ungolfed:

(define(f n)
  (let* ((s (number->string n))
         (sn string->number)
         (st string)
         (lr list-ref)
         (sl (string->list s))
         (g (λ (i) (- (sn(st(lr sl (add1 i))))
                      (sn(st(lr sl i)))))))
    (cond
      [(even? (string-length s))
       #f]
      [(not(equal? s (list->string (reverse sl))))
       #f]
      [else
       (andmap identity
               (for/list ((i (floor(/(length sl)2))))
                 (= 1 (g i))))]
      )))

Teste:

(f 12321) 
(f 123321)  ; only this should be false; 

(f 9)
(f 787)
(f 67876)
(f 4567654)
(f 123454321)
(f 12345654321)
(f 1234567654321)
(f 123456787654321)
(f 12345678987654321)

Saída:

#t
#f
#t
#t
#t
#t
#t
#t
#t
#t
#t
rnso
fonte
1

Java 8, 162 + 19 bytes

19 para import java.util.*;

s->{List f=new ArrayList();for(int i=0;i<9;){String l=String.valueOf(++i);for(int j=i;j>0;){f.add(l);String k=String.valueOf(--j);l=k+l+k;}}return f.contains(s);}

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.

Xanderhall
fonte
1

Oitava, 56 bytes

@(n)nnz(n)<2||~(abs(diff(+n))-1)&&diff(+n(1:1+end/2))==1

Confira todos os casos de teste aqui .

Seriam dois bytes a menos no MATLAB, pois diff(n)funciona para strings. No Octave, você precisa diff(+n).

Explicação:

@(n)                  % Anonymous function taking a string `n` as argument
    nnz(n)<2          % True if there is only one element in n
            ||        % Short circuit or operator. Expression will be true if this is true
~(abs(diff(+n))-1)    % Takes the absolute value of the difference between adjacent numbers
                      % which should always be 1. Subtracts 1, to get 0
                      % and negates it to get 1 (true)
diff(+n(1:1+end/2))==1   % Checks if the difference between the first half of the numbers
                         % is 1.
                      % If either the first, or both the second and third argument is true
                      % then the function will return 1, otherwise 0. 
Stewie Griffin
fonte
1

Mathematica, 56 bytes

Isso é um pouco mais curto:

MatchQ[Differences@IntegerDigits@#,{a:1...,b__}/;b==-a]&
Kelly Lowder
fonte
1

Java 7, 129 119 109 bytes

boolean e(char[]a){int l=a[0]-1,f=0,b=a.length-1;for(;f<b&&a[f]==++l&a[f++]==a[b--];);return f==b&l==a[b]-1;}

Antigo método recursivo, 119

boolean b(char[]a){int b=a.length;return b>1&&a[0]==a[b-1]&a[0]+1==a[1]?b(java.util.Arrays.copyOfRange(a,1,b-1)):b==1;}

-10 bytes graças ao Geobits. Nós são foram amarrados ...

Experimente online!

Cutucar
fonte
Eu acho que você poderia economizar 1 byte com bit a bit and, acho que você usou uma vez, mas não na outra vez? Ou estou lendo errado.
Yodle
@Yodle Eu o usei apenas uma vez porque preciso causar um curto-circuito na primeira condição.
Puxa
11
Parece que você está usando a importação apenas uma vez; portanto, você poderá reduzi-la usando java.util.Arrays.copyOfRange(...)para ignorar a linha de importação.
Geobits
@Geobits good catch ... I derp
Poke
0

Cjam, 35 bytes

Provavelmente muito abaixo do ideal ... Estou um pouco sem prática!

q__W%=\_,_2%@@2/)<2ew{:-}%e`,1=]:e&

Experimente online!

A Simmons
fonte
0

Python 2, 50 82 81 80 bytes

def f(a):b=len(a)/2+1;print(1,0)[a[:b-1]!=a[b:][::-1]or a[:b]not in'123456789']

Abordagem 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.

ElPedro
fonte
11
Isso não verifica se os números estão aumentando estritamente em um. Por exemplo ,, 13531e 6543456ambos retornam incorretamente True.
DJMcMayhem
11
Além disso, as cordas '0'e '1'são verdadeiras.
Dennis
Absolutamente certo. Tem sido um longo dia. Excluirá como inválido.
ElPedro
4
Obrigado pelos comentários e não apenas pela votação.
ElPedro