一个令人愉悦的数字（根据此定义）是可以通过以下过程传递的数字（以我们的41802000示例为例）：

• 分隔尾随相同的数字（41802000 => [41802, 000]）
• 排序数字的前半部分并取最大值（[41802, 000] => [8, 000]）
• 取最后一个元素的长度。调用结果元素A和B（[8, 000] => A=8, B=3）
• N ^B = A是否代表任何整数N？（True在此示例中； 2 ³ = 8）

如果输入True来自以下过程，则认为是令人满意的。

您的任务是取一个整数x，并输出是否x为令人满意的数字。您可以输出真值和假值的任意两个不同的值，但请在回答中说明您使用的是什么。x保证至少有两个不同的数字（例如111，无效的输入）。与大多数挑战一样，您可以将其x视为字符串或数字列表。

这是一个代码高尔夫球，因此以字节为单位的最短代码获胜。

测试用例

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

APL（Dyalog），36字节

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

在线尝试！

怎么样？

几乎是一首诗。

⌽⍵ -一次反转输入，

1,2=/ -获取差异列表。

⌊\ -只保留第一批，

⌽ -并将其翻转完成。

o←-分配给o，

~o -切换1和0，

⍵/⍨ -用它过滤输入

⍎¨ -将结果转换为每个数字的列表，

• ⌈/-并获得最大收益。（那是一个）

⍵/⍨o-使用ounalt（ered）过滤输入，

≢ -取长度，即B。

÷ -得到一个除以该结果，

* -把A带给你。

⊢≡⌊ - 整数？

05AB1E，11个字节

γRćgUZXzm.ï

在线尝试！

说明

γRćgUZXzm.ï〜完整程序。

γ〜分成几串。
 R〜反向。
  ć〜将a [1：]，a [0]推入堆栈。
   g〜长度（a [0]的长度）。
    U〜将其分配给整数变量X。
     ZX〜获得最大值，不弹出，然后按X。
       ZM〜阿1 / B。
         .ï〜是整数吗？

Emigna保存了1个字节。

依赖于以下事实：如果A是一个升为B的幂的正整数N，则N = A ^{1 / B}，因此它必须是整数。

Haskell，85 75 72 71字节

编辑：-10字节通过采用数字列表而不是字符串。感谢WhatToDo指出允许这样做。-3字节归功于Ourous在Clean中的解决方案。-1个字节感谢user28667。

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

在线尝试！将输入作为数字列表。用法示例：f [4,1,8,0,2,0,0,0]yields True。

说明：

给定一个输入s=[4,1,8,0,2,0,0,0]，我们reverse列出并用span(==last s)：分隔主要元素([0,0,0],[2,0,8,1,4])。(b,a)收益b=[0,0,0]和收益的模式匹配a=[2,0,8,1,4]。

列表解析or[n^length b==maximum a|n<-[1..a]]检查是否任何整数n在从范围内1，以9满足n^length b==maximum a，即n^3=8。

Haskell，104 89字节

@Laikoni找到了一个较短的解决方案，但这是我能做的最好的。感谢@Laikoni，让我知道我们也可以接受数字列表作为输入。

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

说明：

在线尝试！

R，80个字节

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

在线尝试！

用于utf8ToInt - 48将数字拆分为数字。这将引发从转换为字符串的警告。

使用rle获取尾数的计数和前几位数的最大值。如果从0到最大值的范围中的任何一个到尾随次数的幂等于最大值，则返回true。

我认为还有更多的高尔夫机会，但这可以等到明天。

果冻，11字节

ŒgµṪL9*€fṀL

将输入作为数字列表。

在线尝试！

怎么运行的

Œ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个字节

这个答案或多或少是MickyT和NofP的答案，应他们的要求，这里是：

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

它以x作为字符串。

> 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个字节

将输入作为字符串或字符数组。返回一个布尔值。

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

测试用例

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

干净，130个 128 118 93字节

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

定义函数@，采用整数列表。

在线尝试！

Python 2中，95 78个字节

• 由于Rod，节省了十七个字节。

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

在线尝试！

[R，93字节

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}

在线尝试！

代码采用整数作为输入，如果数字令人满意，则返回FALSE，否则返回TRUE。

Python 3中，88 85个字节

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

取消高尔夫：

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

• 输入参数应为数字字符串
• 输出为True或False。
• 类似但独立开发的Halvard的答案，但使用浮点运算在不从舍入误差遭受直到办法a ** (1 / b)是关闭的，至少从0.5 ^b √A这需要超过2的值⁵³（或任何浮点基数和尾数Python恰好使用的长度，请参阅sys.float_info）。
• 可以进行少量修改，以仍然可以使用2到36之间的任意数字基。

C（GCC） ，144 126 117字节

• 由于节省了18个字节 Dennis。
• 多亏了ceilingcat，节省了9个字节。

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

在线尝试！

红宝石，64字节

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

输入为字符串，如果满足以下条件，则返回true：

• B == 1（无需检查A）
• A == 4和B == 2
• A == 9和B == 2
• A == 8和B == 3

在线尝试！

Perl 6、55个字节

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

在线尝试！

对初始正则表达式求值后（仅当输入为正$0整数时才能成功），包含数字的初始部分，并且$1包含数字包含尾随重复数字。

comb应用于字符串的不带参数的方法将返回一个字符列表，该字符列表在数字上下文中的值将为列表的长度。所以$0.comb.max前缀中的最大位数是位，$1.comb后缀的长度是。

然后any(^10)，当升至后缀长度的幂时，我们检查（即0-9之间的数字的交点）是否等于前缀中的最大数字。将so要返回部队所产生的交界处，否则只是罚款自身作为truthy值的布尔评价，但只是两个不同的值的挑战要求。

Kotlin，106字节

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

输出：true / false

在线尝试！

加+，21字节

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

在线尝试！

已经三个半月了，我希望我不会对任何人忍者。

C＃（.NET Core），132字节

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

在线尝试！

致谢

-12个字节感谢@KevinCruijssen

去高尔夫

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

Japt，26 18字节

ó¶
o l
ñ o n qV v1

在线尝试！

将输入作为字符串1，0否则返回令人满意的数字。

简短说明：

ó¶

取第一个输入并将其按值拆分(x,y) => x===y为true。例如'41802000'到['4','1','8','0','2','000']。

o l

取从所述第一步骤中的阵列，删除最后一个元件，并得到它的长度，从而得到乙。

ñ o n qV v1

在剩余数组中找到最大的元素，产生A，将其取幂1/B，然后将结果除以1即可返回。

第一次使用Japt，非常欢迎任何建议。
由于ETHproductions减少了8个字节。

Clojure，168个字节

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

在线尝试！

木炭，33字节

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

在线尝试！链接是详细版本的代码。输出a -表示令人愉快的数字。说明：

≔ＥＳιθ

将输入拆分q为字符。

⊞υ⊟θ

从中删除最后一个字符q并将其推送到u（预定义为空列表）。

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

重复弹出并推动，而的最后一个字符q是的第一个字符u。

¬﹪ＸＩ⌈θ∕¹Ｌυ¹

取的最大位数q并将其提高为的倒数的幂u，然后检查结果是否为整数。

Python 2中，91 85个字节

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

在线尝试！

Perl 5，73 +1（-p）= 74字节

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

在线尝试！

Java 8，125字节

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

@ Ayb4btu的C＃.NET答案的端口。

在线尝试。

说明：

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

点，32 22 21字节

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

用途1为falsey和0对truthy，节省了一个字节。在线尝试！

Pyth，29个字节

JezWqezJ=Pz=hZ)K@sh.MsZzZqKsK

测试套件

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