Número que puede comer solo

30

Dado un número entero positivo, genera un valor verdadero / falso en cuanto a si el número puede comerse solo.

Reglas

El extremo izquierdo es la cabeza, el extremo derecho es la cola.

Si la cabeza es mayor o igual que la cola, la cabeza se come la cola y la nueva cabeza se convierte en su suma.

Si , la cabeza se reemplaza por .stumetro10stumetromod10

stumetro=0 0 no se puede ignorar, sin embargo, el número de entrada nunca tendrá ceros a la izquierda.

Ejemplo:

number=2632
head-2, tail-2

2632 -> 463
head-4, tail-3

463 -> 76
head-7, tail-6

76 -> 3
If only one digit remains in the end, the number can eat itself.

Si en algún momento la cabeza no puede comer la cola, la respuesta será falsa.

number=6724
072
False (0<2)

Casos de prueba:

True:
[2632, 92258, 60282, 38410,3210, 2302, 2742, 8628, 6793, 1, 2, 10, 100, 55, 121]

False:
[6724, 47, 472, 60247, 33265, 79350, 83147, 93101, 57088, 69513, 62738, 54754, 23931, 7164, 5289, 3435, 3949, 8630, 5018, 6715, 340, 2194]

Este es el código de golf, por lo que gana el código más corto.

Vedant Kandoi
fuente
¿Podemos tomar la entrada como una cadena?
lirtosiast el
@lirtosiast, sí, pero no una lista de dígitos.
Vedant Kandoi
14
Podrían llamarse números autocanibalísticos .
Arnauld
66
¿Cuál es la razón por la que no podemos tomar como una lista de dígitos? Este problema ya los trata como si fueran listas de dígitos. Obligarlos a ser números significa que solo tiene que anclar código adicional para convertirlos en una lista.
Wheat Wizard
1
¿Se pueden devolver dos valores distintos consistentes en lugar de verdadero / falso?
Olivier Grégoire

Respuestas:

7

JavaScript (ES6),  52 51  50 bytes

Guardado 1 byte gracias a @tsh

Toma la entrada como una cadena. Devuelve un valor booleano.

f=n=>n>[n%10]?f(-(-n[0]-n)%10+n.slice(1,-1)):!n[1]

Pruébalo en línea!

Comentado

f = n =>                 // f = recursive function taking n (a string)
  n > [n % 10]           // The last digit is isolated with n % 10 and turned into a
                         // singleton array, which is eventually coerced to a string
                         // when the comparison occurs.
                         // So we do a lexicographical comparison between n and its
                         // last digit (e.g. '231'>'1' and '202'>'2', but '213'<'3').
  ?                      // If the above result is true:
    f(                   //   do a recursive call:
      -(-n[0] - n) % 10  //     We compute (int(first_digit) + int(n)) mod 10. There's no
                         //     need to isolate the last digit since we do a mod 10 anyway.
      + n.slice(1, -1)   //     We add the middle part, as a string. It may be empty.
    )                    //   end of recursive call
  :                      // else:
    !n[1]                //   return true if n has only 1 digit, or false otherwise
Arnauld
fuente
6

Jalea , 11 bytes

Ṛṙ-µṖÄ%⁵:ḊẠ

Pruébalo en línea!

Cómo funciona

Ṛṙ-µṖÄ%⁵:ḊẠ  Main link. Argument: n

Ṛ            Reverse n, after casting it to a digit list.
 ṙ-          Rotate the result -1 units to the left, i.e., 1 unit to the right.
             Let's call the resulting digit list D.
   µ         Begin a new chain with argument D.
    Ṗ        Pop; remove the last digit.
     Ä       Accumulate; take the cumulative sum of the remaining digits.
      %⁵     Take the sums modulo 10.
         Ḋ   Dequeue; yield D without its first digit.
        :    Perform integer division between the results to both sides.
             Integer division is truthy iff greater-or-equal is truthy.
          Ạ  All; return 1 if all quotients are truthy, 0 if not.
Dennis
fuente
6

Perl 6 , 63 62 bytes

{!grep {.[*-1]>.[0]},(.comb,{.[0,*-1].sum%10,|.[1..*-2]}...1)}

Pruébalo en línea!

Explicación:

{                                                            } # Anonymous code block
                     (                                  ... )       # Create a sequence
                      .comb,  # Starting with the input converted to a list of digits
                            {                          }   # With each element being
                             .[0,*-1]   # The first and last element of the previous list
                                     .sum%10  # Summed and modulo 10
                                            ,|.[1..*-2]   # Followed by the intermediate elements
                                                        ...1 # Until the list is length 1
 !grep   # Do none of the elements of the sequence
       {.[*-1]>.[0]},   # Have the last element larger than the first?
Jo King
fuente
5

Java (JDK) , 83 bytes

n->{int r=0,h=n;while(h>9)h/=10;for(;n>9;h=(h+n)%10,n/=10)r=h<n%10?1:r;return r<1;}

Pruébalo en línea!

Créditos

Olivier Grégoire
fuente
Dada la longitud de las respuestas de Python, siento que me perdí algo ... aunque los casos de prueba están bien.
Olivier Grégoire
No creo que te hayas perdido nada. El Python responde a ambos toman la entrada como una cadena y el uso de indexación, y se toma la entrada como número entero y el uso /10y %10en un bucle. Tan bien hecho superando las respuestas de Python; +1 de mi parte :)
Kevin Cruijssen
1
Puede jugar al golf cambiando un byte r+=a r=y ?1:0hacia ?1:r.
Kevin Cruijssen
@KevinCruijssen De hecho ... las respuestas de Python son subóptimas: los golfs en los comentarios son más cortos que esta respuesta. Además, gracias por el byte guardado! ;-)
Olivier Grégoire
Puede devolver o 1 comenzando y haciendo (guardando 1 byte). 0 01r=1r&=h<n%10?0:r;return r;
Arnauld
4

Mathematica, 62 bytes

0(IntegerDigits@#//.{a_,r___,b_}/;a>=b:>{Mod[a+b,10],r})=={0}&

Primero llama IntegerDigitsa la entrada para obtener una lista de sus dígitos, luego aplica repetidamente la siguiente regla:

{a_,r___,b_}       (* match the first digit, 0 or more medial digits, and the last digit... *)
/;a>=b             (* under the condition that the number is edible... *)
:>{Mod[a+b,10],r}  (* and replace it with the next iteration *)

La regla se aplica hasta que el patrón ya no coincida, en cuyo caso solo queda un dígito (verdadero) o la cabeza es menor que la cola (falso).

En lugar de llamar Length[__]==1, podemos guardar algunos bytes con 0(__)=={0}, multiplicando todos los elementos en la lista 0 y luego comparándolos con la lista {0}.

Pomo de la puerta
fuente
1
En caso de que no lo supieras, TIO tiene Mathematica ahora. Pruébalo en línea!
Dennis
4

Python 3 , 50 bytes

Primera línea robada de la respuesta de Black Owl Kai .

p,*s=map(int,input())
while s:*s,k=s;p%10<k>q;p+=k

Pruébalo en línea!

La salida es a través del código de salida. Falla (1) para entradas falsas y termina (0) para entradas verdaderas.

ovs
fuente
¿Puedes explicar por qué p%10<k>qno arroja un NameError si p%10 >= k?
Black Owl Kai
1
Las comparaciones encadenadas de @BlackOwlKai se evalúan perezosamente en Python. Esto significa que tan pronto como aparezca una primera comparación falsa, la cadena ya no será evaluada. En este caso p%10<k>qhace lo mismo que p%10<k and k>q.
ovs
4

Python 2 , 105 82 81 bytes

i,x=map(int,input()),1
for y in i[:0:-1]:
 if i[0]%10<y:x=0
 else:i[0]+=y
print x

Pruébalo en línea!

Muchas gracias por un masivo -23 de @ ØrjanJohansen

Gracias a @VedantKandoi (y @ ØrjanJohansen) por otro -1

ElPedro
fuente
1
Puede usarlo forcon un corte inverso y también hacer lo %10único cuando realice la prueba: ¡ Pruébelo en línea!
Ørjan Johansen
1
Cambie la condición if-else, if i[0]<i[-1]:x=0y luego else:..... @ ØrjanJohansen, en tu respuesta también.
Vedant Kandoi
@ ØrjanJohansen - Gracias. Eso está muy bien.
ElPedro
Hola @VedantKandoi. Suena bien pero no estoy seguro exactamente a qué te refieres. Me has golpeado en eso. ¿Puedes agregar un TIO por favor? Cuando lo intento funciona para todos los Truecasos pero no para todos False.
ElPedro
1
Creo que @VedantKandoi quiere decir esto .
Ørjan Johansen
4

Brachylog , 23 bytes

ẹ{bkK&⟨h{≥₁+tg}t⟩,K↰|Ȯ}

Pruébalo en línea!

Este es un ahorro de 1 byte sobre la solución de Fatalize . Esto utiliza un enfoque recursivo en lugar de un iterativo

Explicación

ẹ                          Input into a list of digits
 {                    }    Assert that either
  bk                       | the list has at least 2 elements (see later)
      ⟨h{     }t⟩           | and that [head, tail]
         ≥₁                |  | is increasing (head >= tail)
           +               |  | and their sum
            t              |  | mod 10 (take last digit)
             g             |  | as single element of a list
                ,          | concatenated with
  bkK            K         | the number without head and tail (this constrains the number to have at least 2 digits)
                  ↰        | and that this constraint also works on the newly formed number
                   |Ȯ      | OR is a 1 digit number
Kroppeb
fuente
3

APL (Dyalog Unicode) , 33 bytes SBCS

Función de prefijo tácito anónimo que toma una cadena como argumento.

{⊃⍵<t←⊃⌽⍵:03::1⋄∇10|t+@1⊢¯1↓⍵}⍎¨

Pruébalo en línea!

⍎¨ evaluar cada caracter (esto nos da una lista de dígitos)

{... } aplique el siguiente "dfn" a eso; es el argumento (lista de dígitos):

  ⌽⍵ invertir el argumento

   elige el primer elemento (esta es la cola)

  t← asignar a t(para t ail)

  ⍵< para cada uno de los dígitos originales, vea si es menor que eso

   elige el primer verdadero / falso

: si es así:

  0 falso retorno

 luego:

3:: si a partir de ahora, ocurre un error de índice (fuera de los límites):

  1 volver verdadero

  ¯1↓⍵ soltar el último dígito

   producir eso (se separa 1y ¯1no formarán una sola matriz)

  t+@1 agregue la cola al primer dígito (la cabeza)

  10| mod-10

   recurse

Una vez que lleguemos a un solo dígito, ¯1↓haremos que sea una lista vacía y @1provocará un error de índice ya que no hay un primer dígito, haciendo que la función regrese verdadero.

Adán
fuente
3

Python 3 , 77 bytes

p,*s=map(int,input())
print(all(n<=sum(s[i+1:],p)%10for i,n in enumerate(s)))

Pruébalo en línea!


Y mi vieja solución con un enfoque recursivo

Python 3 , 90 bytes

f=lambda x,a=0:2>len(x)if 2>len(x)or(int(x[0])+a)%10<int(x[-1])else f(x[:-1],a+int(x[-1]))

Pruébalo en línea!

Toma la entrada como una cadena.

Black Owl Kai
fuente
3

Brachylog , 24 bytes

ẹ;I⟨⟨h{≥₁+tg}t⟩c{bk}⟩ⁱ⁾Ȯ

Pruébalo en línea!

Debería cambiar el comportamiento predeterminado para que repita un número desconocido de veces (actualmente, itera 1 vez por defecto, lo que es completamente inútil). Entonces no necesitaría el […];I[…]⁾, ahorrando 3 bytes

Explicación

Este programa contiene un tenedor feo dentro de un tenedor. También se necesita un poco de fontanería para trabajar en listas de dígitos en lugar de números (porque si eliminamos la cabeza y la cola 76nos queda 0, lo que no funciona al contrario de [7,6]donde terminamos []).

ẹ                          Input into a list of digits
                       Ȯ   While we don't have a single digit number…
 ;I                  ⁱ⁾    …Iterate I times (I being unknown)…
   ⟨                ⟩      …The following fork:
               c           | Concatenate…
    ⟨         ⟩            | The output of the following fork:
     h       t             | | Take the head H and tail T of the number
      {     }              | | Then apply on [H,T]:
       ≥₁                  | | | H ≥ T
         +                 | | | Sum them
          tg               | | | Take the last digit (i.e. mod 10) and wrap it in a list
                {  }       | With the output of the following predicate:
                 bk        | | Remove the head and the tail of the number
Fatalizar
fuente
Usando la recursión en lugar de la iteración y reemplazando el c-fork para usar ,en su lugar, podría eliminar 1 byte ¡ Pruébelo en línea!
Kroppeb
@Kroppeb Realmente genial. ¡Creo que deberías publicar tu propia respuesta, porque es significativamente diferente a la mía!
Fatalize
3

Haskell, 70 64 60 bytes

f(a:b)=b==""||a>=last b&&f(last(show$read[a]+read b):init b)

La entrada se toma como una cadena.

Pruébalo en línea!

Editar: -6 bytes usando el truco de @ Laikoni de usar en ||lugar de guardias separados. Otros -4 bytes gracias a @Laikoni.

nimi
fuente
3
read[l b]puede ser solo read bporque solo miras el último dígito de todos modos. Ahorra 4 bytes más también en línea last: ¡ Pruébelo en línea!
Laikoni
2

Python 2 , 75 67 bytes

l=lambda n:n==n[0]or n[-1]<=n[0]*l(`int(n[0]+n[-1],11)%10`+n[1:-1])

Pruébalo en línea!

Enfoque lambda recursivo. Toma la entrada como una cadena. ¡Muchas gracias a Dennis por guardar 8 bytes!

ArBo
fuente
2

Haskell , 69 64 bytes

f n=read[show n!!0]#n
h#n=n<10||h>=mod n 10&&mod(h+n)10#div n 10

Pruébalo en línea! Ejemplo de uso: f 2632rendimientos True.

Editar: -5 bytes porquemod (h + mod n 10) 10 = mod (h + n) 10

Laikoni
fuente
buen uso de || , que también me ayudó a acortar mi respuesta. ¡Gracias!
nimi
2

Rubí, 139 bytes

->(a){a.length==1?(p true;exit):1;(a[0].to_i>=a[-1].to_i)?(a[0]=(a[-1].to_i+a[0].to_i).divmod(10)[1].to_s;a=a[0..-2];p b[a]):p(false);exit}

Pruébalo en línea! (tiene un código extra para procesar la entrada, ya que es una función)

Código sin golf:

->(a) do
    if a.length == 1
        p true
        exit
    if a[0].to_i >= a[-1].to_i
        a[0] = (a[-1].to_i + a[0].to_i).divmod(10)[1].to_s
        a = a[0..-2]
        p b[a]
    else
        p false
        exit
    end
end
CG One Handed
fuente
1

Retina 0.8.2 , 42 bytes

\d
$*#;
^((#*).*;)\2;$
$2$1
}`#{10}

^#*;$

Pruébalo en línea! Enlace incluye casos de prueba. Explicación:

\d
$*#;

Convierta los dígitos en unarios e inserte separadores.

^((#*).*;)\2;$
$2$1

Si el último dígito no es mayor que el primero, agréguelos juntos.

#{10}

Reduzca el módulo 10 si corresponde.

}`

Repita hasta que el último dígito sea mayor que el primero o solo quede un dígito.

^#*;$

Comprueba si solo queda un dígito.

Neil
fuente
1

05AB1E , 26 25 24 bytes

[DgD#\ÁD2£D`›i0qëSOθs¦¦«

Probablemente se pueda jugar un poco más de golf. Parece demasiado largo, pero tal vez el desafío es en términos de código más complejo de lo que pensaba de antemano.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

[                 # Start an infinite loop
 D                #  Duplicate the top of the stack
                  #  (which is the input implicitly in the first iteration)
  gD              #  Take its length and duplicate it
    #             #  If its a single digit:
                  #   Stop the infinite loop
                  #   (and output the duplicated length of 1 (truthy) implicitly)
                  #  Else:
  \               #   Discard the duplicate length
   Á              #   Rotate the digits once towards the left
    D2£           #   Duplicate, and take the first two digits of the rotated number
       D`         #   Duplicate, and push the digits loose to the stack
         i       #   If the first digit is larger than the second digit:
           0      #    Push a 0 (falsey)
            q     #    Stop the program (and output 0 implicitly)
          ë       #   Else (first digit is smaller than or equal to the second digit):
           SO     #    Sum the two digits
             θ    #    Leave only the last digit of that sum
           s      #    Swap to take the rotated number
            ¦¦    #    Remove the first two digits
              «   #    Merge it together with the calculated new digit
Kevin Cruijssen
fuente
1

C ++ (gcc) , 144 bytes

bool f(std::string b){int c=b.length();while(c>1){if(b[0]<b[c-1])return 0;else{b[0]=(b[0]-48+b[c-1]-48)%10+48;b=b.substr(0,c-1);--c;}}return 1;}

Pruébalo en línea!

La primera vez que intento algo como esto, así que si formateé algo incorrecto, avíseme. No estoy 100% seguro de las reglas para cosas como usar el espacio de nombres para eliminar los 5 bytes "std ::", así que lo dejé.

Sin golf:

bool hunger(std::string input)
{
    int count=input.length();
    while (count>1)
    {
        if (input[0]<input[count-1])                         //if at any point the head cannot eat the tail we can quit the loop
                                                             //comparisons can be done without switching from ascii
        {
            return false;
        }
        else
        {
             input[0]=(input[0]-48+input[count-1]-48)%10+48; //eating operation has to occur on integers so subtract 48 to convert from ASCII to a number
             input=input.substr(0,count-1);                  //get rid of the last number since it was eaten
             --count;
        }

    }
    return true;                                             //if the end of the loop is reached the number has eaten itself
}
Ben H
fuente
1
En teoría, también necesitas #includedeclaraciones. Sin embargo, propondría programar en el subdialecto de instalaciones std lib de C ++ con #include "std_lib_facilities.h"prepended, que también hace a using namespace std;. Ese encabezado fue escrito por el autor del lenguaje desde hace mucho tiempo (la última versión es 2010) para estudiantes nuevos en C ++.
Yakk
@Yakk A menos que cree y publique un intérprete que haga esto por usted, aún necesita contar la inclusión de std_lib_facilities.h.
Dennis
@BenH ¡Bienvenido a PPCG! Necesita el recuento de todas las inclusiones necesarias para compilar su función. El método más corto que conozco es #import<string>. Pruébalo en línea!
Dennis
@Dennis #!/usr/bin/shnewline gcc -include "std_lib_facilities.h" $@: si encuentro un curso de C ++ que proporciona ese script de shell, ¿eso contaría?
Yakk
@Yakk no sabía sobre ese cambio. A diferencia de las declaraciones #include, los argumentos de la línea de comandos son gratuitos porque son esencialmente un nuevo lenguaje . En C ++ (gcc)-include iostream , esto es de hecho 144 bytes.
Dennis
1

C #, 114 bytes

static bool L(string n){return n.Skip(1).Reverse().Select(x=>x%16).Aggregate(n[0]%16,(h,x)=>h>=x?(h+x)%10:-1)>=0;}

Pruébalo en línea

bien
fuente
1

C (gcc) (con string.h) , 110 108 bytes

c;f(char*b){c=strlen(b);if(!c)return 1;char*d=b+c-1;if(*b<*d)return 0;*b=(*b+*d-96)%10+48;*d=0;return f(b);}

Pruébalo en línea!

Todavía es relativamente nuevo en PPCG, por lo que la sintaxis correcta para vincular bibliotecas como un nuevo idioma es extraña para mí. También tenga en cuenta que la función devuelve 0 o 1 para falso / verdadero, y la impresión de ese resultado en stdout requiere stdio. Si estamos siendo pedantes y el ejercicio requiere resultados, el lenguaje también requiere stdio .

Conceptualmente similar a la respuesta de @ BenH, pero en C, así que felicitaciones donde se deben (Bienvenido a PPCG, por cierto), pero usando la recursividad. También utiliza aritmética de puntero de matriz, porque el código sucio es más corto que el código limpio.

La función es recursiva de cola, con condiciones de salida si el primer número no puede comer el último o la longitud es 1, devolviendo falso o verdadero, respectivamente. Estos valores se encuentran desreferenciando un puntero a la cadena C (que da un carácter) al principio y al final de la cadena, y haciendo las comparaciones en ellos. La aritmética del puntero se realiza para encontrar el final de la cadena. finalmente, el último carácter se "borra" reemplazándolo con un terminador nulo (0).

Es posible que la aritmética del módulo se acorte en un byte o dos, pero ya necesito una ducha después de la manipulación del puntero.

Versión sin golf aquí

Actualización: se guardaron dos bytes reemplazando c == 1 con! C. Esto es esencialmente c == 0. Se ejecutará un tiempo adicional y se duplicará innecesariamente antes de eliminarse, pero ahorra dos bytes. Un efecto secundario es nulo o las cadenas de longitud cero no causarán una recursión infinita (aunque no deberíamos obtener cadenas nulas, ya que el ejercicio dice enteros positivos).

Andrew Baumher
fuente
No necesita vincular bibliotecas en el caso de que gcc, aunque se generarán advertencias, gcccompilarán su código sin #includes. Además, puede guardar 4 bytes con -DR=return. Finalmente, en su código de prueba, los \0s son innecesarios, ya que la cadena literalmente ya los incluye implícitamente.
1
Además, puede regresar de una función asignando a la primera variable: b=case1?res1:case2?res2:res_else;es lo mismo queif(case1)return res1;if(case2)return res2;return res_else;
Aún más, puede arrojar algunos bytes adicionales al no usar c: puede determinar si la cadena es de longitud cero head-tail.
No me di cuenta de que podía usar operadores ternarios (condicionales) en C. ¿Siempre ha sido así? En cualquier caso, es bueno saberlo; Los usaré en el futuro. Saludos
Andrew Baumher
1

Powershell, 89 bytes

"$args"-notmatch'(.)(.*)(.)'-or(($m=$Matches).1-ge$m.3-and(.\g(''+(+$m.1+$m.3)%10+$m.2)))

¡Importante! El guión se llama a sí mismo de forma recursiva. Así que guarde el script como g.ps1archivo en el directorio actual. También puede llamar a una variable de bloque de script en lugar de un archivo de script (consulte el script de prueba a continuación). Eso llama tiene la misma longitud.

Nota 1: El script usa una evaluación perezosa de operadores lógicos -ory -and. Si "$args"-notmatch'(.)(.*)(.)'es, Trueentonces -orno se evalúa la subexpresión correcta de . Además, si ($m=$Matches).1-ge$m.3es Falseasí, la subexpresión correcta de -andno se evalúa también. Entonces evitamos la recursión infinita.

Nota 2: La expresión regular '(.)(.*)(.)'no contiene anclajes de inicio y fin porque la expresión (.*)es codiciosa por defecto.

Script de prueba

$g={
"$args"-notmatch'(.)(.*)(.)'-or(($m=$Matches).1-ge$m.3-and(&$g(''+(+$m.1+$m.3)%10+$m.2)))
}

@(
    ,(2632, $true)
    ,(92258, $true)
    ,(60282, $true)
    ,(38410, $true)
    ,(3210, $true)
    ,(2302, $true)
    ,(2742, $true)
    ,(8628, $true)
    ,(6793, $true)
    ,(1, $true)
    ,(2, $true)
    ,(10, $true)
    ,(100, $true)
    ,(55, $true)
    ,(121, $true)
    ,(6724, $false)
    ,(47, $false)
    ,(472, $false)
    ,(60247, $false)
    ,(33265, $false)
    ,(79350, $false)
    ,(83147, $false)
    ,(93101, $false)
    ,(57088, $false)
    ,(69513, $false)
    ,(62738, $false)
    ,(54754, $false)
    ,(23931, $false)
    ,(7164, $false)
    ,(5289, $false)
    ,(3435, $false)
    ,(3949, $false)
    ,(8630, $false)
    ,(5018, $false)
    ,(6715, $false)
    ,(340, $false)
    ,(2194, $false)
) | %{
    $n,$expected = $_
   #$result = .\g $n   # uncomment this line to call a script file g.ps1
    $result = &$g $n   # uncomment this line to call a script block variable $g
                       # the script block call and the script file call has same length
    "$($result-eq-$expected): $result <- $n"
}

Salida:

True: True <- 2632
True: True <- 92258
True: True <- 60282
True: True <- 38410
True: True <- 3210
True: True <- 2302
True: True <- 2742
True: True <- 8628
True: True <- 6793
True: True <- 1
True: True <- 2
True: True <- 10
True: True <- 100
True: True <- 55
True: True <- 121
True: False <- 6724
True: False <- 47
True: False <- 472
True: False <- 60247
True: False <- 33265
True: False <- 79350
True: False <- 83147
True: False <- 93101
True: False <- 57088
True: False <- 69513
True: False <- 62738
True: False <- 54754
True: False <- 23931
True: False <- 7164
True: False <- 5289
True: False <- 3435
True: False <- 3949
True: False <- 8630
True: False <- 5018
True: False <- 6715
True: False <- 340
True: False <- 2194

Powershell, 90 bytes

Sin recursión Sin dependencia de nombre de archivo y sin dependencia de nombre de bloque de script.

for($s="$args";$s[1]-and$s-ge$s%10){$s=''+(2+$s[0]+$s)%10+($s|% S*g 1($s.Length-2))}!$s[1]

Un Powershell convierte implícitamente un operando derecho en un tipo de operando izquierdo. Por lo tanto, $s-ge$s%10calcula el operando derecho $s%10como integery compárelo como stringporque el tipo del operando izquierdo es string. Y 2+$s[0]+$sconvierte un carácter $s[0]y una cadena $sen integerporque el operando izquierdo 2es entero.

$s|% S*g 1($s.Length-2)es un atajo para$s.Substring(1,($s.Length-2))

mazzy
fuente
1

C # (compilador interactivo de Visual C #) , 69 bytes

x=>{for(int h=x[0],i=x.Length;i>1;)h=h<x[--i]?h/0:48+(h+x[i]-96)%10;}

Pruébalo en línea!

El éxito o el fracaso están determinados por la presencia o ausencia de una excepción . La entrada tiene la forma de una cadena.

Menos golf ...

// x is the input as a string
x=>{
  // h is the head
  for(int h=x[0],
    // i is an index to the tail
    i=x.Length;
    // continue until the tail is at 0
    i>1;)
      // is head smaller larger than tail?
      h=h<x[--i]
        // throw an exception
        ?h/0
        // calculate the next head
        :48+(h+x[i]-96)%10;
}

Hay un par de bytes adicionales para tratar la conversión entre caracteres y dígitos, pero en general eso no afectó demasiado el tamaño.

dana
fuente
1

Brachylog , 18 bytes

ẹ⟨k{z₁{≥₁+t}ᵐ}t⟩ⁱȮ

Pruébalo en línea!

Toma tres bytes fuera de la solución de Fatalize por el solo hecho de superscriptless no determinista existente ahora, pero pierde otros tres por hacer las cosas vagamente inspirados Jelly-con z₁evitar el uso de c, go incluso h. (También se inspiró al intentar y no utilizar una nueva característica diferente: el ʰmetapredicado).

                 Ȯ    A list of length 1
                ⁱ     can be obtained from repeatedly applying the following
ẹ                     to the list of the input's digits:
 ⟨k{         }t⟩      take the list without its last element paired with its last element,
    z₁                non-cycling zip that pair (pairing the first element of the list with
                      the last element and the remaining elements with nothing),
      {    }ᵐ         and for each resulting zipped pair or singleton list:
       ≥₁             it is non-increasing (trivially true of a singleton list);
          t           take the last digit of
         +            its sum.
Cadena no relacionada
fuente
0

PowerShell , 94 91 bytes

for(;$n-and$n[0]-ge$n[-1]){$n=$n-replace"^.",((+$n[0]+$n[-1]-96)%10)-replace".$"}return !$n

Pruébalo en línea!


Script de prueba

function f($n){

for(;$n-and$n[0]-ge$n[-1]){$n=$n-replace"^.",((+$n[0]+$n[-1]-96)%10)-replace".$"}return !$n

Remove-Variable n
}
Write-Host True values:
@(2632, 92258, 60282, 38410,3210, 2302, 2742, 8628, 6793, 1, 2, 10, 100, 55, 121) |
    % { Write-Host "  $_ $(' '*(6-$_.ToString().Length)) $(f $_.ToString())" }

Write-Host False values:
@(6724, 47, 472, 60247, 33265, 79350, 83147, 93101, 57088, 69513, 62738, 54754, 23931, 7164, 5289, 3435, 3949, 8630, 5018, 6715, 340, 2194) | 
    % { Write-Host "  $_ $(' '*(6-$_.ToString().Length)) $(f $_.ToString())" }

Código sin golf:

function f ($inVar){
    # While the Input exists, and the first character is greater than last
    while($inVar -and ($inVar[0] -ge $inVar[-1])){

        # Calculate the first integer -> ((+$n[0]+$n[-1]-96)%10)
        $summationChars = [int]$inVar[0]+ [int]$inVar[-1]
        # $summationChars adds the ascii values, not the integer literals. 
        $summationResult = $summationChars - 48*2
        $summationModulo = $summationResult % 10

        # Replace first character with the modulo
        $inVar = $inVar -replace "^.", $summationModulo

        # Remove last character
        $inVar = $inVar -replace ".$"
    }
    # Either it doesn't exist (Returns $True), or 
    # it exists since $inVar[0] < $inVar[-1] returning $False
    return !$inVar
}
KGlasier
fuente
1
No debería necesitar verificar $n[0]su forestado de cuenta; solo verificar $ndebería ser suficiente.
AdmBorkBork
En su -6lugar, podría usarlo -96porque es suficiente para
calcular
usted podría quitar return y guardar 7 bytes
mazzy
y creo que deberías incluir una declaración de parámetro en el recuento de bytes. ya sea param($n)o function f($n).
mazzy
1
@mazzy El póster declaró en los comentarios que se le permitía usar cadenas, simplemente no se le permitía dar la entrada como una lista de números / cadenas. Interpreté esto como ["1","2","3"]una entrada no válida pero lo "123"es. si @VedantKandoi tiene un problema, definitivamente puedo cambiarlo.
KGlasier