Приємне число (згідно з цим визначенням) - це число, яке може бути передано за допомогою наступного процесу (давайте використаємо 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є приємне число. Ви можете вивести будь-які два різних значення для truthy та falsey, але, будь ласка, вкажіть, що ви використовуєте у своїй відповіді. 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 - комутатори та нуль (и),

⍵/⍨ - фільтруйте вхід за допомогою нього,

⍎¨ - перетворити результат у список кожної цифри,

• ⌈/- і отримайте максимум. (це A)

⍵/⍨o- фільтрувати вхід за допомогою ounalt (ered),

≢ - і візьміть довжину, яка була б B.

÷ - розділіть цей результат,

* - І візьми А до тієї сили тобі.

⊢≡⌊ - ціле число?

05AB1E , 11 байт

γRćgUZXzm.ï

Спробуйте в Інтернеті!

Пояснення

γRćgUZXzm.ï ~ Повна програма.

γ ~ Розділити на проміжки цифр.
 R ~ Реверс.
  ć ~ Натисніть a [1:], a [0] до стеку.
   g ~ Довжина (a [0]).
    U ~ Призначте це цілочисленній змінній X.
     ZX ~ Отримайте максимум, не вискакуючи, і натисніть X.
       ZM ~ A 1 / В .
         .ï ~ Це ціле число?

Емінья зберегла 1 байт.

Покладається на те, що якщо A - додатне ціле число N, підняте на потужність B , то N = A ^{1 / B} , отже, воно повинно бути цілим числом.

Haskell , 85 75 72 71 байт

Редагувати : -10 байт, взявши список цифр замість рядка. Завдяки WhatToDo за те, що вказали , що це дозволено. -3 байти завдяки розчину Ourous в «Чистому» . -1 байт завдяки користувачу28667 .

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]врожайність 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до , тобто .9n^length b==maximum an^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 до максимуму до значення кінцевого числа дорівнює максимальному значенню.

Я думаю, що є інші можливості для гольфу, але це може зачекати до завтра.

Желе , 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

Він приймає х як рядок.

> 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 байт

• Збережено сімнадцять байтів завдяки Роду .

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}

Спробуйте в Інтернеті!

Код приймає ціле число як вхідне і повертає ЛІЖНЕ, якщо число приємне, а ІСТИНА в іншому випадку.

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.
• Подібно до ще розробленого незалежно від відповіді Хальварда, але використовує арифметику з плаваючою точкою таким чином, що не страждає від помилок округлення, поки a ** (1 / b)не вимкнеться щонайменше на 0,5 від ^b √a, що вимагає значення вище 2 ⁵³ (або будь- якого радіаса та мантіси з плаваючою точкою довжина, яку Python використовує, див. sys.float_info).
• Можна тривіально модифікувати для роботи з умовними базами чисел між 2 і 36.

C (gcc) , 144 126 117 байт

• Збережено вісімнадцять байтів завдяки Деннісу .
• Збережено дев'ять байтів завдяки стельовій коті .

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)
• А == 4 і В == 2
• А == 9 і В == 2
• А == 8 і В == 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, але проблема вимагає тільки два різних значень , які будуть повернуті.

Котлін , 106 байт

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

Вихід: вірно / хибно

Спробуйте в Інтернеті!

Додайте ++ , 21 байт

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

Спробуйте в Інтернеті!

Минуло 3 з половиною місяці, я сподіваюся, що я нікого не кину.

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

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

Japt, 26 18 bytes

ó¶
o l
ñ o n qV v1

Try it online!

Takes input as a string, returns 1 for pleasing numbers, 0 otherwise.

Short explanation:

ó¶

Take the first input and split it by values where (x,y) => x===y is true. For example '41802000' to ['4','1','8','0','2','000'].

o l

Take the array from the first step, remove the last element and get its length, yielding B.

ñ o n qV v1

Find the largest element in the remaining array, yielding A, take it to the power 1/B and then return if the result is divisible by one.

First time working with Japt, very open to any recommendations.
Shaved off 8 bytes thanks to 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)))

Try it online!

Charcoal, 33 bytes

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

Try it online! Link is to verbose version of code. Outputs a - for pleasing numbers. Explanation:

≔ＥＳιθ

Split the input q into characters.

⊞υ⊟θ

Remove the last character from q and push it to u (predefined to an empty list).

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

Repeatly pop and push while the last character of q is the first character of u.

¬﹪ＸＩ⌈θ∕¹Ｌυ¹

Take the maximum digit of q and raise it to the power of the reciprocal of the length of u, then check whether the result is an integer.

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

Try it online!

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

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

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

Port of @Ayb4btu's C# .NET answer.

Try it online.

Explanation:

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

Uses 1 for falsey and 0 for truthy, saving a byte. Try it online!

Pyth, 29 bytes

JezWqezJ=Pz=hZ)K@sh.MsZzZqKsK

Test suite

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