Un numero gradevole (secondo questa definizione) è un numero che può essere passato attraverso il seguente processo (usiamo 41802000come esempio):

• Separare i numeri identici finali ( 41802000 => [41802, 000])
• Ordina la prima metà delle cifre e prendi il massimo ([41802, 000] => [8, 000] )
• Prendi la lunghezza dell'elemento finale. Chiama gli elementi risultanti A e B ( [8, 000] => A=8, B=3)
• N ^B = A per qualsiasi numero intero N? ( Truein questo esempio; 2 ³ = 8)

Se l'input risulta Truedal seguente processo, è considerato piacevole.

Il tuo compito è prendere un numero intero xe generare se xè un numero gradevole. Puoi generare due valori distinti per verità e falsità, ma per favore indica cosa stai usando nella tua risposta. xè garantito che contenga almeno due cifre distinte (ad es. 111un input non valido). Come con la maggior parte delle sfide, potresti prenderex una stringa o un elenco di cifre.

Questo è un codice-golf quindi vince il codice più breve in byte .

Casi test

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

APL (Dyalog) , 36 byte

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

Provalo online!

Come?

Quasi una poesia.

⌽⍵ - invertire l'ingresso una volta,

1,2=/ - ottieni l'elenco delle differenze.

⌊\ - mantenere solo il primo gruppo di quelli,

⌽ - e capovolgilo per completare.

o←- assegnare a o,

~o - scambia uno e zero (s),

⍵/⍨ - filtra l'input con esso,

⍎¨ - trasforma il risultato in un elenco di ogni cifra,

• ⌈/- e ottieni il massimo. (è un)

⍵/⍨o- filtra l'ingresso con ounalt (ered),

≢ - e prendere la lunghezza, sarebbe B.

÷ - ottenere uno diviso per questo risultato,

* - e porta A a quel potere.

⊢≡⌊ - numero intero?

05AB1E , 11 byte

γRćgUZXzm.ï

Provalo online!

Spiegazione

γRćgUZXzm.ï ~ Programma completo.

γ ~ Dividi in serie di cifre.
 R ~ Inverso.
  ~ Spingere a [1:], a [0] nello stack.
   g ~ Lunghezza (di a [0]).
    U ~ Assegnalo alla variabile intera X.
     ZX ~ Ottieni il massimo, senza scoppiare, e premi X.
       zm ~ A 1 / B .
         .ï ~ È un numero intero?

Emigna ha salvato 1 byte.

Si basa sul fatto che se A è un numero intero positivo N elevato alla potenza di B , allora N = A ^{1 / B} , quindi deve essere un numero intero.

Haskell , 85 75 72 71 byte

Modifica : -10 byte prendendo un elenco di cifre anziché una stringa. Grazie a WhatToDo per aver sottolineato che questo è permesso. -3 byte grazie a soluzione Ourous in Clean . -1 byte grazie a user28667 .

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

Provalo online! Accetta input come un elenco di cifre. Esempio di utilizzo: f [4,1,8,0,2,0,0,0]rese True.

Spiegazione:

Dato un input s=[4,1,8,0,2,0,0,0], selezioniamo reversel'elenco e separiamo gli elementi principalispan(==last s) : ([0,0,0],[2,0,8,1,4]). Il pattern matching su (b,a)rese b=[0,0,0]e a=[2,0,8,1,4].

La comprensione dell'elenco or[n^length b==maximum a|n<-[1..a]]controlla se qualsiasi numero intero nnell'intervallo da 1a 9soddisfa n^length b==maximum a, cioèn^3=8 .

Haskell , 104 89 byte

@Laikoni ha trovato una soluzione più breve , ma questa è la migliore che potessi fare. Grazie @Laikoni per avermi fatto sapere che possiamo anche accettare elenchi di cifre come input.

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

Spiegazione:

Provalo online!

R , 80 byte

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

Provalo online!

usi utf8ToInt - 48 per dividere il numero in cifre. Ciò genera un avviso dalla conversione a una stringa.

Usando rle ottieni il conteggio delle cifre finali e il valore massimo delle prime cifre. Restituisce vero se qualsiasi valore compreso nell'intervallo 0 al valore massimo alla potenza del conteggio finale è uguale al valore massimo.

Penso che ci siano ulteriori opportunità per giocare a golf, ma questo può aspettare fino a domani.

Gelatina , 11 byte

ŒgµṪL9*€fṀL

Accetta input come un elenco di cifre.

Provalo online!

Come funziona

Œ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 byte

Questa risposta è più o meno un miscuglio delle risposte di MickyT e NofP e, su loro richiesta, eccola:

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

Prende x come stringa.

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

Accetta l'input come una stringa o una matrice di caratteri. Restituisce un valore booleano.

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

Casi test

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

Pulito , 130 128 118 93 byte

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

Definisce la funzione @, prendendo un elenco di cifre intere.

Provalo online!

Python 2 , 95 78 byte

• Risparmio diciassette byte grazie a Rod .

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

Provalo online!

R , 93 byte

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}

Provalo online!

Il codice accetta un numero intero come input e restituisce FALSE se il numero è soddisfacente, e TRUE altrimenti.

Python 3 , 88 85 byte

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

• L'argomento di input dovrebbe essere una stringa di cifre
• L'output è Trueo False.
• Simile a ancora sviluppato indipendentemente dalla risposta di Halvard ma utilizza l'aritmetica in virgola mobile in un modo che non soffre di errori di arrotondamento fino a quando non a ** (1 / b)viene spento di almeno 0,5 da ^b √a che richiede un valore superiore a 2 ⁵³ (o qualunque radix e mantissa in virgola mobile lunghezza che Python usa, vedisys.float_info ).
• Può essere modificato in modo banale per funzionare ancora con basi numeriche arbitrarie tra 2 e 36.

C (gcc) , 144 126 117 byte

• Risparmiato diciotto byte grazie a Dennis .
• Risparmiato nove byte grazie a 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);}

Provalo online!

Rubino , 64 byte

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

Immettere come stringa, restituisce vero se:

• B == 1 (non è necessario controllare A)
• A == 4 e B == 2
• A == 9 e B == 2
• A == 8 e B == 3

Provalo online!

Perl 6 , 55 byte

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

Provalo online!

Dopo la valutazione della regex iniziale - che può avere esito positivo solo se l'input è un numero intero positivo - $0contiene la parte iniziale del numero e$1 contiene le cifre ripetute finali.

Il combmetodo senza argomenti, applicato a una stringa, restituisce un elenco di caratteri, che in un contesto numerico valuta la lunghezza dell'elenco. Quindi $0.comb.maxè la più grande delle cifre nel prefisso e$1.comb è la lunghezza del suffisso.

Quindi controlliamo se any(^10)(ovvero, la giunzione or dei numeri da 0-9), quando elevato alla potenza della lunghezza del suffisso, è uguale alla cifra più grande nel prefisso. Le soforze booleane valutano la giunzione risultante, che altrimenti andrebbe bene da sola come valore veritiero, ma la sfida richiede che vengano restituiti solo due valori distinti.

Kotlin , 106 byte

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

Uscita: vero / falso

Provalo online!

Aggiungi ++ , 21 byte

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

Provalo online!

Sono passati 3 mesi e mezzo, spero di non essere un ninja per nessuno.

C # (.NET Core) , 132 byte

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

Provalo online!

Ringraziamenti

-12 byte grazie 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;
}

Japt , 26 18 byte

ó¶
o l
ñ o n qV v1

Provalo online!

Accetta input come stringa, restituisce 1numeri gradevoli,0 altrimenti.

Breve spiegazione:

ó¶

Prendi il primo input e dividerlo per valori dove (x,y) => x===yè vero. Ad esempio '41802000'a ['4','1','8','0','2','000'].

o l

Prendere la matrice dal primo passo, rimuovere l'ultimo elemento e ottenere la sua lunghezza, ottenendo B .

ñ o n qV v1

Trova l'elemento più grande nell'array rimanente, producendo A , portalo alla potenza 1/Be poi ritorna se il risultato è divisibile per uno.

Lavorare per la prima volta con Japt, molto aperto a qualsiasi consiglio. Rimozione di
8 byte grazie a ETHproductions .

Clojure, 168 byte

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

Provalo online!

Carbone , 33 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Emette a -per numeri piacevoli. Spiegazione:

≔ＥＳιθ

Dividi l'input qin caratteri.

⊞υ⊟θ

Rimuovi l'ultimo carattere qe spingilo su u(predefinito in un elenco vuoto).

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

Pop ripetutamente e spingere mentre l'ultimo personaggio di q è il primo carattere di u.

¬﹪ＸＩ⌈θ∕¹Ｌυ¹

Prendi la cifra massima di qe aumentala alla potenza del reciproco della lunghezza di u, quindi controlla se il risultato è un numero intero.

Python 2 , 91 85 byte

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

Provalo online!

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

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

Provalo online!

Java 8, 125 byte

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 della risposta C # .NET di @ Ayb4btu .

Provalo online.

Spiegazione:

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 byte

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

Usi 1per Falsey e 0per truthy , risparmiando un byte. Provalo online!

Pyth, 29 byte

JezWqezJ=Pz=hZ)K@sh.MsZzZqKsK

Suite di test

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