¡Dios mío Giza Golf!

41

Un "número de Giza", también conocido coloquialmente como un número de Timmy, es cualquier número donde los dígitos representan una pirámide ( A134810 ). Por ejemplo, "12321" es un número de giza porque se puede visualizar así:

  3  
 2 2
1   1

Sin embargo, algo como "123321" no es un número de Giza porque hay dos dígitos en la parte superior de la pirámide

  33  
 2  2
1    1

En otras palabras, un número es un número de Giza si se cumplen todas las siguientes condiciones:

  • Tiene un número impar de dígitos, y el dígito central es el más grande.

  • Es palindrómico (la misma lectura hacia adelante o hacia atrás), y

  • La primera mitad de los dígitos aumenta estrictamente en uno. (Dado que debe ser palindrómico, esto significa que la segunda mitad de los dígitos debe estar disminuyendo estrictamente en uno)

Debe escribir un programa completo o una función que tome un entero positivo como entrada, y determinar si es un número de Giza o no. Puede tomar la entrada como una cadena o como un número. Si es un número de Giza, genera un valor verdadero . De lo contrario, un valor falso.

Hay un total de 45 números de Giza, por lo que cualquiera de estas entradas debería dar como resultado un valor verdadero:

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

Cualquier otra entrada debe dar un valor falso. Por supuesto, no tiene que manejar entradas no válidas, como números no positivos, no enteros o no números.

Como de costumbre, este es el , por lo que las lagunas estándar están prohibidas y la respuesta más corta en bytes gana.

DJMcMayhem
fuente
¿Qué hay de 0? ¿Es eso una verdad?
tuskiomi
@tuskiomi Técnicamente, no, pero es irrelevante porque no tienes que manejar números no positivos.
DJMcMayhem
1
La razón por la que pregunto es porque si es un número de giza, entonces números como 1210, 123210, etc. también serían verdaderos.
tuskiomi
55
@tuskiomi Ninguno de los dos es palindrómico o tiene un número impar de dígitos. A menos que esté contando un 0 inicial pero eso hace que todo sea mucho más complicado.
DJMcMayhem
1
@ nedla2004 Creo que los ceros iniciales hacen que los formatos de entrada sean más complicados. Para mantener todo agradable y simple, diremos que puede suponer que las entradas no contendrán ceros iniciales.
DJMcMayhem

Respuestas:

30

Python 2, 48 47 46 bytes

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

Pruébalo en Ideone .

Cómo funciona

En Python, una comparación encadenada devuelve True si y solo si todas las comparaciones individuales hacen lo mismo. En este caso específico, nuestra lambda devuelve True si y solo si se cumplen todas las siguientes condiciones.

  • s[~len(s)/2:]in'987654321'

    Para una cadena s de longitud 2n + 1 , ~len(s)/2devuelve ~ (2n + 1) / 2 = - (2n + 2) / 2 = - (n + 1) , por lo que s[~len(s)/2:]produce los n + 1 caracteres más a la derecha de s .

    Del mismo modo, para una cadena s de longitud 2n , ~len(s)/2devuelve ~ (2n) / 2 = - (2n + 1) / 2 = - (n + 1) (la división entera siempre se redondea hacia -∞ , por lo que s[~len(s)/2:]una vez más se obtiene el n + más a la derecha 1 caracteres de s

    La comparación devuelve True si y solo si los n + 1 más a la derecha forman una subcadena de 987654321.

    Tenga en cuenta que si lo hacen y s tiene 2n caracteres, s no puede ser un palíndromo; el n º y (n + 1) th personajes de la derecha será distinto, y el segundo es el n º personaje de la izquierda.

  • '987654321'>s

    Esto compara las cadenas lexicográficamente. Como 9 es el único número de Giza que comienza con 9 , todos los números de Giza satisfacen esta comparación.

    Tenga en cuenta que comparar estas cadenas no forma parte de nuestro problema de decisión; >ses simplemente tres caracteres más cortos que and s.

  • s==s[::-1]

    Esto devuelve True si y solo si s es un palíndromo.

Dennis
fuente
8
Esta respuesta es una magia loca. Entiendo cómo funcionan los fragmentos, pero ni siquiera puedo comenzar a comprender cómo se te ocurrió. Y por un momento allí, estaba orgulloso de mi 64. +1
DJMcMayhem
2
Me
22

Perl, 39 37 42 39 + 1 = 40 bytes

Usando un nuevo método, logré reducir una gran cantidad de bytes. Corre con la -nbandera. Acepta la entrada repetidamente en tiempo de ejecución, imprimiendo 0 o 1 en consecuencia.

Tuve que agregar 5 bytes porque me di cuenta de que sin él, el código funcionaba para entradas como 1234567900987654321, que no es un número de Giza. Como los números de Giza nunca contienen el dígito 0 (y todos los falsos positivos necesariamente contendrían el dígito 0), estos 5 bytes explican eso.

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

Explicación:

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.

El propósito de la expresión regular de sustitución es construir una cadena de 1s cuya longitud es la mitad de la longitud de la entrada, redondeada hacia arriba. Por lo tanto, una entrada de 12321producirá la cadena 111, que luego se eleva al cuadrado (explicación a continuación). Las entradas de longitud uniforme producirán cadenas que son demasiado pequeñas para garantizar que la expresión regular final sea exitosa.

La razón por la que funciona este código se debe a lo siguiente:

        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 el número de 1 en RHS es igual a 1/2 más de la mitad del tamaño de LHS. (1 más si truncamos). Adicionalmente:

567898765 - 123454321 = 444444444, que es solo 4 repeticiones. Entonces, cuando restamos nuestro cuadrado de nuestro número, si obtenemos un repdigit, nuestro número original es un número de Giza.

Código antiguo y método antiguo (58 + 1 = 59 bytes)

Guardado 1 byte gracias a @Dada

Ejecutar con la -nbandera, el texto de la tubería al usarecho

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

Calcula el número único de giza determinado por la longitud y el entero principal, y ve si coincide con la entrada.

Ejecutar como echo -n "123454321" | perl -M5.010 -n giza.pl devoluciones 1si es un número de Giza, de lo contrario es nulo.

Gabriel Benamy
fuente
2
Esa es una hermosa observación para el segundo método.
trichoplax
15

Gelatina , 10 7 6 bytes

9ẆŒBḌċ

Genera los 45 números de números de Giza, luego prueba la membresía.

Pruébalo en línea! o ver los números generados .

Cómo 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
fuente
10

JavaScript (ES6), 46 45 42 41 bytes

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

Toma la entrada como una cadena y devuelve una cadena de un solo dígito para verdadero, 0para falso.

La idea básica es verificar algunas cosas:

  • Si la cadena tiene una longitud de caracteres, O
  • el primer carácter es igual al último carácter y
  • la sección central también es un número de Giza, y
  • el segundo personaje es uno más que el primer personaje aquí.
ETHproducciones
fuente
Lo siento, leí mal la pregunta.
Neil
10

Java 7, 128119105 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;}

¡No más cuerdas! Entonces, ahora empiezo generando un 111...número de la misma longitud que input ( a), y uno más corto a square ( b). Luego puede restar b*bde la entrada y verificar la divisibilidad por a. csolo está ahí para verificar impar / par, no le prestes atención

Espacio en blanco:

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 antiguo, 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;}

Recorre la matriz y comprueba una diferencia de 1 (o -1, según la mitad) entre cada dígito. Luego solo verifica que la longitud sea extraña.

Espacio en blanco:

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
fuente
¿Por qué necesita verificar si el primero es el mismo que el último?
Nathan Merrill
3
No tengo idea de lo que quieres decir> _>
Geobits
¿Es esta una respuesta válida considerando que el problema especifica que la función debe tomar un número entero positivo? Por supuesto, una matriz de caracteres puede representar un número entero positivo, pero creo que es una distinción importante.
Hypino
1
@Hypino El problema dice que la entrada se puede tomar como una cadena o un entero, y char[] cuenta como una cadena aquí, por lo que diría que es válida.
Geobits
@Geobits Ah, me perdí la parte donde decía que podría tomarse como una Cadena.
Hypino
6

05AB1E , 9 8 bytes

La verdad es 1 , la falsedad es 0 .

9LŒ€ûJ¹å

Utiliza la codificación CP-1252 . Pruébalo en línea!

Adnan
fuente
Creo que eso 2ä¬û¹Qtambién funcionaría y ahorra dos bytes.
Osable
@Osable 12521 no es un número de giza, esto falla para el elemento del medio.
Magic Octopus Urn
Ahora me doy cuenta de que me salté el tercer punto (dígitos consecutivos). ¡No importa!
Osable
Ahhhh ... Estaba usando prefijos, tendré en cuenta las subcadenas para futuros esfuerzos, pequeño truco ordenado.
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]))

Una solución recursiva simple. Comprueba si el primer y el último dígito son iguales y el segundo dígito menos uno. Luego comprueba si el centro también es un número de Giza. Devuelve verdadero una vez que se reduce a un solo dígito.

¡Un byte guardado gracias a @Rod, una tonelada de bytes guardados gracias a DLosc y ETHProductions!

DJMcMayhem
fuente
se puede intercambiar len(s)==1con 1==len(s)al ahorro 1 byte en el espacio, también, los ands se podrían sustituir por *salvar 3 bytes
Rod
Solo para agregar al comentario de Rod: 1ortambién funciona. (Mientras no sea un 0precedente, entonces oPython cree que es un número octal)
DLosc
1
Por lo general, no puede reemplazar andcon *cuando se requiere un comportamiento de cortocircuito, ya que está en una función recursiva. El primero anddebe ser reemplazable, pero necesita dos conjuntos de paréntesis, lo que niega cualquier ahorro. (cc: @Rod)
DLosc
1
No sé mucho Python, pero ¿podrías 1) eliminar el int()alrededor s[0]o 2) usar s[0]==`int(s[1])-1` ?
ETHproductions
1
Basándose en la sugerencia de @ETHproductions: s[-1]==s[0]==`int(s[1])-1`(requiere Python 2 específicamente).
DLosc
6

PowerShell v3 +, 147 108 67 bytes

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

Enfoque radicalmente cambiado. Genera todos los números posibles de Giza y luego verifica si la entrada $args[0]es -inesa colección. A continuación se muestra cómo se forma la colección de números de Giza:

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

Ejecuciones de ejemplo:

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
fuente
108 -> 67 ... parece que ganaste esta vez (y probablemente la mayor parte del tiempo): P
Yodle
5

Python 3, 65 bytes

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

No estoy completamente seguro, pero creo que esto funciona.

0WJYxW9FMN
fuente
1
No hay números de Giza que comiencen 0, puede eliminar eso :) Tampoco habrá números más largos que 17 que satisfagan esa condición, por lo que tampoco necesita eso. Es esencialmente la misma solución que Dennis tiene :)
Kade
@Shebang pero este fue publicado primero ...
Rod
@ Rod No estaba afirmando que copió ni nada :)
Kade
@Shebang Tampoco estoy c:
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 del hecho de que 11^2=121, 111^2=12321y así sucesivamente, calculo esto y agrego 1111..suficientes veces como compensación.
Ejemplos:
23432=111^2+11111*1
676=11^2+111*5

Barra
fuente
Como no está llamando f, no necesita nombrarlo realmente. Puede guardar dos bytes eliminandof=
DJMcMayhem
Deberías poner un límite a esto. La entrada 1234567900987654321devuelve verdadero, cuando debería ser falso.
Geobits
@Geobits ooops, arreglado (¿supongo?)
Rod
4

Perl, 41 bytes

40 bytes de código + -pbanderas.

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

Salidas 1 si la entrada es un número de Giza, nada de lo contrario. Proporcione la entrada sin nueva línea final para ejecutarla:

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

Explicaciones : primero, s/(.)(?=(.))/$1-$2/gereemplace cada dígito $1(seguido de $2) por $1-$2. Si es un número de Giza, entonces cada dígito es uno menos que el siguiente al principio y uno más al final, entonces la cadena debe contener solo -1en la primera parte y 1en la segunda (excepto la última que no se modifica) . Eso es lo que /^(-1(?1)1|).$/verifica la segunda parte : busca un -1seguido de recursión seguido de a 1.

-1 byte gracias a Martin Ender.


Mi versión anterior 15 bytes más (bastante diferente, así que lo dejaré aquí):

echo -n '123456787654321' | perl -F -pe '$\=$_ eq reverse;$\&=$F[$_-1]+1==$F[$_]for 1..@F/2}{'
Dada
fuente
La única parte de esto que no entiendo es el propósito de |la segunda expresión regular.
Gabriel Benamy
@GabrielBenamy Ese es el caso base del bloque recursivo (es decir, no coincide con nada y detiene la recursividad).
Dada
3

> <> PESCADO 57 52 49 48 bytes

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

Editar 1: = devuelve 0 o 1 si es verdadero, por lo que eliminó una verificación y usó este valor para incrementar, luego verifica la igualdad después de todos modos. (guardado 6 bytes, perdido 1 para la nueva línea).

Editar 2: 3 marcadores direccionales eliminados y 11 colocados en el espacio para compensar la pila a una longitud uniforme para forzar falso (3 bytes guardados).

Edición 3: Duplique la longitud de la pila para verificar MOD por 2 y len (1), esto se hizo poniendo la longitud dos veces antes, pero ahora llena un espacio vacío en la línea 2 (1 byte guardado).

Pelícano verde azulado
fuente
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 con algunos casos de prueba:

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
    }
}

¡Hurra por los condicionales de una sola línea, ahora superando la respuesta de Java :)! También pude escribir mis primeros comentarios explicativos, aunque probablemente se explica por sí mismo. Gracias a @Dada por encontrar un problema con mi algoritmo (fue cierto para los números que se reflejaron como 13631). Ahora sub 100 ya que aparentemente la comprobación de la longitud% 2 es redundante.

Yodle
fuente
1
¿No volvería esto truepara números como 13631? Además, dado que realiza una llamada recursiva x, creo que debe incluir x=en su recuento de bytes.
Dada
@Dada Heh buen punto, sabía que me faltaba algo ... Y está bien, los agregaré a la cuenta.
Yodle
Espera, ¿estás superando qué ahora? ;)
Geobits
@Geobits Dangit!
Veré
3

Bash, 111 bytes

ACTUALIZAR

Tenga en cuenta que la normalización del número de entrada probablemente se puede omitir por completo, si solo agrega el primer dígito a su número GIZA generado , así:

01210 + 6 => 67876

y luego simplemente compárelo con la entrada directamente.

Descargo de responsabilidad: este no está realmente optimizado, por lo que es más una prueba de concepto que un verdadero contendiente

Golfed

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

Cualquier número de GIZA se puede normalizar a su forma canónica, restando su primer dígito del resto:

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

y solo hay un número canónico GIZA de una longitud particular.

Sabiendo esto, podemos generar fácilmente un número canónico de GIZA basado en la longitud del número de entrada:

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

luego normalice el número de entrada:

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

y comparar

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

Prueba

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
zepelín
fuente
Espero que no te importe, implementé una parte de este algoritmo en mi respuesta :)
FlipTack
1

En realidad , 22 bytes

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

Pruébalo en línea!

Toma la entrada como una cadena entre comillas (por ejemplo "12321"). La salida es un entero positivo para verdadero y 0para falso.

Explicación:

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
fuente
1

Haskell, 62 bytes

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

La entrada se toma como una cadena.

Crea una lista de todos los números de Giza y comprueba si el número está en él. La lista se crea un bucle ia través '1'..'9'y luego ja través '1'..iy la creación de los elementos j .. i-1 , i , i-1 .. j.

nimi
fuente
1

> <> , 62 bytes

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

Pruébalo en línea!

Salidas 1 para un número de Giza; 0 de lo contrario. Funciona empujando la entrada a una cola (ok, técnicamente una pila reversible) y probando repetidamente ambos extremos para la igualdad, así como asegurándose de que sean exactamente uno más grande que el valor anterior.

Brian Gradin
fuente
1

CJam , 20 19 bytes

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

Banco de pruebas.

Explicación

La idea básica es encontrar el dígito mínimo y máximo, luego crear un número de Giza a partir de ellos y luego verificar que sea equivalente a la 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.

En lugar del carácter mínimo, también podemos usar el primer carácter, para el mismo número de bytes:

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

Mathematica, 62 61 60 bytes

Se guardaron 2 bytes debido a @MartinEnder .

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

Composición de funciones. Toma un número como entrada y devuelve Trueo Falsecomo salida.

LegionMammal978
fuente
1

Retina, 55 54 36 bytes

El recuento de bytes asume la codificación ISO 8859-1.

.
$*1:
+`^(1+:)(1\1.*)\b\1$
$2
^1+:$

Pruébalo en línea

Convierta cada dígito a unario, separado por dos puntos. Bucle, eliminando los dígitos externos coincidentes si el siguiente dígito es uno más. Une un solo dígito restante.

mbomb007
fuente
1
Esto acepta12312
Martin Ender
1

PHP, 71 bytes

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

recupera el dígito más grande de la entrada y cuenta hacia atrás, agregando el nuevo dígito a una cadena de comparación hasta que la entrada y la cadena de comparación sean iguales, o lo $isean 0.

imprime el dígito más bajo para un número de Timmy, de lo 0contrario.

Titus
fuente
1

Pushy , 30 15 bytes

Me desperté esta mañana y me di cuenta de que podía responder la mitad de mi respuesta ...

s&K-kL2/OvhXwx#

(no compite como el desafío de las fechas posteriores al idioma)

De entrada se da en la línea de comandos: $ pushy gizas.pshy 3456543. Salidas 1para la verdad y 0para la falsedad. Aquí está el desglose:

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

El algoritmo se inspiró en la respuesta bash: primero, normalice el número, ( 45654 -> 01210), luego genere el número de giza normalizado de la misma longitud (solo hay uno) y compare.


Antigua solución

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

Raqueta 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))))]))

Sin golf:

(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))))]
      )))

Pruebas:

(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)

Salida:

#t
#f
#t
#t
#t
#t
#t
#t
#t
#t
#t
rnso
fuente
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);}

Enfoque diferente a la otra respuesta de Java, quería probar y usar el método de crear todos los números de Timmy posibles y verificar si nuestra cadena estaba contenida en ellos.

Xanderhall
fuente
1

Octava, 56 bytes

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

Echa un vistazo a todos los casos de prueba aquí .

Esto sería dos bytes menos en MATLAB, ya que diff(n)funciona para cadenas. En Octave, lo necesitas diff(+n).

Explicación:

@(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
fuente
1

Mathematica, 56 bytes

Esto es un poco más corto:

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

Java 7, 129119109 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;}

Viejo 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 gracias a Geobits. Nos estamos ataron ...

Pruébalo en línea!

Meter
fuente
Creo que podría guardar 1 byte con bit a bit and, creo que lo usó una vez pero no la otra vez? O lo estoy leyendo mal.
Yodle
@Yodle Solo lo usé una vez porque necesito un cortocircuito para la primera condición.
Poke
1
Parece que solo está usando la importación una vez, por lo que debería poder acortar esto al usar java.util.Arrays.copyOfRange(...)para omitir la línea de importación.
Geobits
@Geobits buena captura ... Derp
Poke
0

Cjam, 35 bytes

Probablemente muy subóptima ... ¡Estoy un poco fuera de práctica!

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

Pruébalo en línea!

Un simmons
fuente
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']

Enfoque simple Simplemente divide la cadena por la mitad (omitiendo el carácter del medio o uno después del carácter del medio si es de longitud uniforme), invierte la segunda mitad y luego compara los dos y compara la primera mitad con una cadena del 1 al 9.

Editar

Publicado de nuevo después de comentarios constructivos de otros jugadores de golf y al darme cuenta y corregir mis errores.

-1 por perder un (desperdicio de) espacio

-1 para leer la pregunta nuevamente y darse cuenta de que no necesitamos tener 0 en cuenta. Realmente debe dejar de jugar al golf después de un largo día de trabajo.

ElPedro
fuente
1
Esto no verifica si los números están aumentando estrictamente en uno. Por ejemplo, 13531y 6543456ambos devuelven incorrectamente True.
DJMcMayhem
1
Además, las cuerdas '0'y '1'ambas son verdaderas.
Dennis
Absolutamente correcto. Ha sido un largo día. Se eliminará como no válido.
ElPedro
44
Gracias por los comentarios y no solo por votar.
ElPedro