Um número agradável (de acordo com esta definição) é um número que pode ser passado pelo processo a seguir (vamos usar 41802000como exemplo):

• Separe os números idênticos à direita ( 41802000 => [41802, 000])
• Classifique a primeira metade dos dígitos e leve o máximo ( [41802, 000] => [8, 000])
• Pegue o comprimento do elemento final. Chame os elementos resultantes A e B ( [8, 000] => A=8, B=3)
• N ^B = A para qualquer número inteiro N? ( Trueneste exemplo; 2 ³ = 8)

Se a entrada resultar Truedo processo a seguir, ela será considerada agradável.

Sua tarefa é pegar um número inteiro xe produzir se xé um número agradável. Você pode gerar dois valores distintos para truthy e falsey, mas indique o que está usando em sua resposta. xé garantido que tenha pelo menos dois dígitos distintos (por exemplo, 111é uma entrada inválida). Como na maioria dos desafios, você pode usar xuma string ou uma lista de dígitos.

Este é um código-golf, pelo que o código mais curto em bytes vence.

Casos de teste

          Input          Output
       41802000               1
            100               1
      123456788               0
      451111111               0
234543454545444               0
             12               1
       41902000               0
          92599               1

APL (Dyalog) , 36 bytes

{(⊢≡⌊)(⌈/⍎¨⍵/⍨~o)*÷≢⍵/⍨o←⌽⌊\1,2=/⌽⍵}

Experimente online!

Quão?

Quase um poema.

⌽⍵ - reverta a entrada uma vez,

1,2=/ - obtenha a lista de diferenças.

⌊\ - mantenha apenas o primeiro grupo de pessoas,

⌽ - e vire para completar.

o←- atribuir a o,

~o - trocar uns e zero (s),

⍵/⍨ - filtrar a entrada com ele,

⍎¨ - transforme o resultado na lista de cada dígito,

• ⌈/- e obtenha o máximo. (aquilo é um)

⍵/⍨o- filtrar a entrada com ounalt (ered),

≢ - e levar o comprimento, isso seria B.

÷ - divida uma por esse resultado,

* - e leve A a esse poder.

⊢≡⌊ - inteiro?

05AB1E , 11 bytes

γRćgUZXzm.ï

Experimente online!

Explicação

γRćgUZXzm.ï ~ Programa completo.

γ ~ Divida em séries de dígitos.
 R ~ Reverso.
  Pressione ~ [1:], a [0] para a pilha.
   g ~ Comprimento (de a [0]).
    U ~ Atribua isso à variável inteira X.
     ZX ~ Obtenha o máximo, sem avançar, e pressione X.
       zm ~ A 1 / B .
         .ï ~ É um número inteiro?

Emigna salvou 1 byte.

Baseia-se no fato de que, se A é um número inteiro positivo N elevado à potência de B , então N = A ^{1 / B} , portanto, ele deve ser um número inteiro.

Haskell , 85 75 72 71 bytes

Edite : -10 bytes, tomando uma lista de dígitos em vez de uma string. Obrigado ao WhatToDo por apontar que isso é permitido. -3 bytes graças à solução Ourous no Clean . -1 byte graças a user28667 .

f s|(b,a)<-span(==last s)$reverse s=or[n^length b==maximum a|n<-[1..9]]

Experimente online! Recebe a entrada como uma lista de dígitos. Exemplo de uso: f [4,1,8,0,2,0,0,0]rendimentos True.

Explicação:

Dada uma entrada s=[4,1,8,0,2,0,0,0], nós reverseda lista e separar os elementos que conduzem com span(==last s): ([0,0,0],[2,0,8,1,4]). O padrão correspondente nos (b,a)rendimentos b=[0,0,0]e a=[2,0,8,1,4].

As lista de compreensão or[n^length b==maximum a|n<-[1..a]]verifica se qualquer inteiro nno intervalo entre 1a 9satisfaz n^length b==maximum a, isto é n^3=8.

Haskell , 104 89 bytes

A @Laikoni encontrou uma solução mais curta , mas é o melhor que posso fazer. Obrigado @Laikoni por me informar que também podemos aceitar listas de dígitos como entrada.

import Data.List
(g.length.last<*>maximum.concat.init).group
g b a=any(==a)$(^b)<$>[1..a]

Explicação:

Experimente online!

R , 80 bytes

function(x)any((0:(m=max((d=rle(rev(utf8ToInt(c(x,''))-48)))$v[-1])))^d$l[1]==m)

Experimente online!

Usa utf8ToInt - 48para dividir o número em dígitos. Isso lança um aviso da conversão em uma string.

Usando rle, obtenha a contagem dos dígitos finais e o valor máximo dos primeiros dígitos. Retorne true se qualquer um dos valores de 0 a max no poder da contagem à direita for igual a max value.

Penso que existem mais oportunidades de golfe, mas isso pode esperar até amanhã.

Gelatina , 11 bytes

ŒgµṪL9*€fṀL

Recebe a entrada como uma lista de dígitos.

Experimente online!

Como funciona

ŒgµṪL9*€fṀL  Main link. Argument: D (digit array)

Œg           Group runs of digits, yielding a run array R.
  µ          Begin a new chain with argument D.
   Ṫ         Tail; remove and yield the last element of D.
    L        Take the length. Let's call it b.
     9*€     Compute [1**b, ..., 9**b].
         Ṁ   Take the maximum run in R, yileding [a, ..., a].
        f    Filter, yielding either [a] (if a = n**b for some n) or [].
          L  Take the length. 

R, 66 bytes

Esta resposta é mais ou menos uma mistura das respostas de MickyT e NofP e, a pedido delas, aqui está:

function(x,R=rle(rev(utf8ToInt(x)-48)))!max(R$v[-1])^(1/R$l[1])%%1

Leva x como uma string.

> f=function(x,R=rle(rev(utf8ToInt(x)-48)))!max(R$v[-1])^(1/R$l[1])%%1
> f("41802000")
[1] TRUE
> f("100")
[1] TRUE
> f("123456788")
[1] FALSE
> f("451111111")
[1] FALSE
> f("234543454545444")
[1] FALSE
> f("12")
[1] TRUE
> f("41902000")
[1] FALSE

JavaScript (ES7), 66 bytes

Recebe a entrada como uma sequência ou uma matriz de caracteres. Retorna um booleano.

f=([c,...s],m)=>s.some(n=>n-c)?f(s,c<m?m:c):!(m**(1/-~s.length)%1)

Casos de teste

f=([c,...s],m)=>s.some(n=>n-c)?f(s,c<m?m:c):!(m**(1/-~s.length)%1)

console.log(f(       '41802000')) // 1
console.log(f(            '100')) // 1
console.log(f(      '123456788')) // 0
console.log(f(      '451111111')) // 0
console.log(f('234543454545444')) // 0
console.log(f(             '12')) // 1

Limpo , 130 128 118 93 bytes

import StdEnv
@l#(b,a)=span((==)(last l))(reverse l)
=or[n^length b==last(sort a)\\n<-[0..9]]

Define a função @, obtendo uma lista de dígitos inteiros.

Experimente online!

Python 2 , 95 78 bytes

• Economizou dezessete bytes graças a Rod .

def f(s,i=~0):
	while s[i]==s[~0]:i-=1
	return int(max(s[:-~i]))**(1./~i)%1==0

Experimente online!

R , 93 bytes

function(x){n=nchar(x)
d=x%/%10^(n:1-1)%%10
i=max(which(d!=d[n]))
max(d[1:i])^(1/(n-i))%%1>0}

Experimente online!

O código usa um número inteiro como entrada e retorna FALSE se o número for agradável e TRUE caso contrário.

Python 3 , 88 85 bytes

def f(n):p=n.rstrip(n[-1]);a=int(max(p));b=len(n)-len(p);return round(a**(1/b))**b==a

Ungolfed:

def is_pleasing_number( n ):
    prefix = n.rstrip(n[-1])
    a = int(max(prefix))
    b = len(n) - len(prefix)
    return round(a ** (1 / b)) ** b == a

• O argumento de entrada deve ser uma sequência de dígitos
• A saída é Trueou False.
• Semelhante ao ainda desenvolvido independentemente da resposta de Halvard, mas usa aritmética de ponto flutuante de uma maneira que não sofra erros de arredondamento até que a ** (1 / b)seja desligado em pelo menos 0,5 de ^b √a, que requer um valor acima de 2 ⁵³ (ou qualquer radix e mantissa de ponto flutuante passa a usar Python, veja sys.float_info).
• Pode ser modificado trivialmente para continuar trabalhando com bases de números arbitrárias entre 2 e 36.

C (gcc) , 144 126 117 bytes

• Economizou dezoito bytes graças a Dennis .
• Economizou nove bytes graças ao ceilingcat .

j,k,m;f(char*N){N+=j=strlen(N);k=~j;for(j=-1;m=N[j--]==N[j];);for(;k++<j;)m=fmax(N[k],m);j=!fmod(pow(m-48,1./~j),1);}

Experimente online!

Ruby , 64 bytes

->a{!([a[/(\d)\1*$/].size,$`.chars.max]*?x!~/x1$|^2x[49]|^3x8/)}

Entrada como uma string, retorna true se:

• B == 1 (não é necessário marcar A)
• A == 4 e B == 2
• A == 9 e B == 2
• A == 8 e B == 3

Experimente online!

Perl 6 , 55 bytes

{m/(\d+?)((\d)$0*)$/;so any(^10)**$1.comb==$0.comb.max}

Experimente online!

Após a avaliação do regex inicial - que só pode ser bem-sucedido se a entrada for um número inteiro positivo - $0contém a parte inicial do número e $1os dígitos repetidos à direita.

O combmétodo sem argumentos, aplicado a uma seqüência de caracteres, retorna uma lista de caracteres que, em contexto numérico, é avaliada pelo comprimento da lista. Então, $0.comb.maxé o maior dos dígitos do prefixo e $1.combo comprimento do sufixo.

Depois, verificamos se any(^10)(ou seja, a junção ou dos números de 0 a 9), quando aumentada para a potência do comprimento do sufixo, é igual ao maior dígito do prefixo. A soavaliação booleana da força da junção resultante, que de outra forma seria adequada por si só como um valor verdadeiro, mas o desafio exige que apenas dois valores distintos sejam retornados.

Kotlin , 106 bytes

fun String.p()=split(Regex("(?=(.)\\1*$)")).let{Math.pow((it[0].max()?:'0')-'0'+.0,1.0/(it.size-1))}%1==.0

Saída: verdadeiro / falso

Experimente online!

Adicionar ++ , 21 bytes

L,BGubLV@¦+bMG1$/^1%!

Experimente online!

Faz 3 meses e meio, espero não estar ninando ninguém.

C # (.NET Core) , 132 bytes

n=>{int A=0,B=1,s=1,i=n.Length-1;for(;i-->0;)if(n[i]==n[i+1]&s>0)B++;else{A=n[i]>A?n[i]:A;s=0;}return System.Math.Pow(A,1d/B)%1==0;}

Experimente online!

Agradecimentos

-12 bytes graças a @KevinCruijssen

DeGolfed

n=>{
    int A=0, // maximum digit
        B=1, // count of trailing identical numbers
        s=1, // 1 if dealing with trailing numbers, 0 otherwise
        i=n.Length-1;

    for(; i-- > 0;)
        if(n[i] == n[i+1] & s > 0)
            B++;
        else
        {
            A = n[i] > A? n[i] : A;
            s = 0;
        }

    return Math.Pow(A, 1d/B) % 1 == 0;
}

Japonês , 26 18 bytes

ó¶
o l
ñ o n qV v1

Experimente online!

Pega a entrada como uma string e retorna 1para números agradáveis, 0caso contrário.

Breve explicação:

ó¶

Pegue a primeira entrada e divida-a por valores onde (x,y) => x===yfor verdadeira. Por exemplo '41802000'para ['4','1','8','0','2','000'].

o l

Tome a matriz da primeira etapa, remover o último elemento e obter seu comprimento, produzindo B .

ñ o n qV v1

Encontre o maior elemento da matriz restante, produzindo A , leve-o à potência 1/Be retorne se o resultado for divisível por um.

Primeira vez que trabalhei com o Japt, muito aberto a quaisquer recomendações. Raspou
8 bytes graças a ETHproductions .

Clojure, 168 bytes

(fn[x](let[y(reverse(vec x))z(count(take-while #(= %(first y))y))a(apply max(map #(-(int %)48)(drop z y)))b(Math/pow a(/ 1 z))](<(Math/abs(- b(Math/round b)))0.00001)))

Experimente online!

Carvão , 33 bytes

≔ＥＳιθ⊞υ⊟θＷ⁼§υ⁰§θ±¹⊞υ⊟θ¬﹪ＸＩ⌈θ∕¹Ｌυ¹

Experimente online! Link é a versão detalhada do código. Emite a -para números agradáveis. Explicação:

≔ＥＳιθ

Divida a entrada qem caracteres.

⊞υ⊟θ

Remova o último caractere de qe empurre-o para u(predefinido para uma lista vazia).

Ｗ⁼§υ⁰§θ±¹⊞υ⊟θ

Estale e empurre repetidamente enquanto o último caractere de qé o primeiro caractere de u.

¬﹪ＸＩ⌈θ∕¹Ｌυ¹

Pegue o dígito máximo de qe aumente à potência do inverso do comprimento de u, depois verifique se o resultado é um número inteiro.

Python 2 , 91 85 bytes

s=`input()`;d=0
p=s.rstrip(s[-1])
exec"`d**(len(s)-len(p))`==max(p)>exit(1);d+=1;"*10

Experimente online!

Perl 5 , 73 + 1 ( -p) = 74 bytes

s/(.)\1*$//;$/=length$&;$_=(sort/./g)[-1];$q=$"++**$/while$q<$a;$_=$q==$a

Experimente online!

Java 8, 125 bytes

a->{int A=0,B=1,f=1,i=a.length-1;for(;i-->0;)if(a[i]==a[i+1]&f>0)B++;else{A=a[i]>A?a[i]:A;f=0;}return Math.pow(A,1d/B)%1==0;}

Porta da resposta C # .NET de @ Ayb4btu .

Experimente online.

Explicação:

a->{                       // Method with digit-array parameter and boolean return-type
  int A=0,                 //  Maximum digit `A` as specified in the challenge description
      B=1,                 //  `B` as specified in the challenge description
      f=1,                 //  Flag-integer, starting at 1
      i=a.length-1;        //  Index integer `i`
  for(;i-->0;)             //  Loop `i` backwards over the digits (excluding the last)
    if(a[i]==a[i+1]        //   If the current and next digits are the same,
       &f>0)               //   and the flag is still 1
      B++;                 //    Increase `B` by 1
    else{                  //   Else:
      A=a[i]>A?            //    If the current digit is larger than `A` 
         a[i]              //     Replace `A` with the current digit
        :                  //    Else:
         A;                //     Leave `A` the same
      f=0;}                //    Set the flag-integer to 0
  return Math.pow(A,1d/B)  //  Return if `A` ^ (1/`B`)
    %1==0;}                //  is an exact integer

Pip , 32 22 21 bytes

'.N(#a-#Ya<|a@v)RTMXy

Usa 1para falsey e 0para verdade , economizando um byte. Experimente online!

Pitão, 29 bytes

JezWqezJ=Pz=hZ)K@sh.MsZzZqKsK

Suíte de teste

Z=0
z=input()
J=z[-1]
while z[-1]==J:
    z=z[:-1]
    Z+=1
K=max(map(int,z))**(1/Z)
print(K==int(K))