Disarium Dilemma

Un Disarium è definito come un numero il cui:

la somma delle sue cifre alimentate con la loro rispettiva posizione è uguale al numero originale

Il tuo compito :

Hai una strana ossessione per i numeri classificati come disarium. La necessità di seguire le vie del disarium è così grande in te che ti rifiuti di leggere qualsiasi pagina numerata non disarium in un dato libro. Hai due GRANDI problemi:

1. Il tuo professore ti ha appena assegnato a leggere il tuo libro di testo da una pagina nall'altram
2. Hai colpito la testa molto duramente la scorsa settimana e non riesci a ricordare come determinare a livello di programmazione se un numero è considerato un disarium.

Il tempo è essenziale, quindi il codice per determinare le pagine che dovrai leggere deve essere il più breve possibile.

È necessario identificare tutto il disarium in un intervallo inclusivo di nthrough m.

Esempi di un disarium :

89 = 8 ¹ + 9 ²

135 = 1 ¹ + 3 ² + 5 ³

518 = 5 ¹ + 1 ² + 8 ³

Questo è code-golf, quindi vince il minor numero di byte!

Ecco la sequenza completa di A032799 .

Perl 6 , 40 39 byte

{grep {$_==sum .comb Z**1..*},$^a..$^b}

Provalo online!

Come funziona

{                                     }  # A lambda.
                              $^a..$^b   # Range between the two lambda arguments.
 grep {                     },           # Return numbers from that range which satisfy:
               .comb Z  1..*             #  Digits zipped with the sequence 1,2,3,...,
                      **                 #  with exponentiation operator applied to each pair,
           sum                           #  and those exponents summed,
       $_==                              #  equals the number.

Python2, 98 89 88 84 byte

lambda n,m:[x for x in range(n,m+1)if sum(int(m)**-~p for p,m in enumerate(`x`))==x]

Orribile. Si accorcia. Iniziando a sembrare migliore

Ecco il mio tentativo ricorsivo (86 byte):

f=lambda n,m:[]if n>m else[n]*(sum(int(m)**-~p for p,m in enumerate(`n`))==n)+f(n+1,m)

Grazie a @Rod per aver salvato 4 byte! rangea enumeratee così via.

Perl, 43 byte

map{say if$_==eval s/./+$&**$+[0]/gr}<>..<>

Provalo online!

Regex è davvero potente, ragazzi.

Spiegazione

La prima cosa che fa il codice è leggere due numeri interi come input via <>e crea un intervallo dal primo al secondo ... Quindi esso utilizza lo standard mapfunzione per scorrere questa gamma, e applica il seguente codice a ciascun valore: say if$_==eval s/./+$&**$+[0]/gr. Sembra incomprensibile, e lo è, ma ecco cosa sta succedendo davvero.

mapmemorizza implicitamente il suo valore corrente nella variabile $_. Molte funzioni e operazioni perl usano questo valore quando non ne viene dato nessuno. Ciò include espressioni regolari, come l' s///operatore di sostituzione.

Ci sono quattro parti in una regex di sostituzione:

1. Stringa da manipolare. Di solito, l'operatore =~viene utilizzato per applicare una regex a una stringa, ma se questo operatore è assente, la regex viene applicata alla variabile implicita $_, che contiene il nostro numero corrente tramite la mapfunzione.
2. Stringa da cercare. In questo caso, stiamo cercando qualsiasi carattere non di nuova riga singola, indicata con il carattere jolly .. In effetti, stiamo acquisendo ogni singola cifra.
3. Stringa da sostituire con. Sostituiamo un segno più +seguito da un'espressione matematica, mescolata con alcune variabili magiche del Perl che rendono tutto molto più semplice.

La speciale variabile scalare $&contiene sempre la totalità dell'ultima acquisizione regex riuscita, che in questo caso è una singola cifra. La variabile matrice speciale @+contiene sempre un elenco di offset post-corrispondenza per l'ultima corrispondenza corretta, ovvero l'indice del testo dopo la corrispondenza. $+[0]è l'indice in $_del testo che segue immediatamente $&. Nel caso di 135, catturiamo la cifra 1e l'indice nel 135testo immediatamente successivo (ovvero, 35) è 1, che è il nostro esponente. Quindi, vogliamo aumentare $&(1) alla potenza di $+[0](1) e ottenere 1. Vogliamo aumentare 3 alla potenza di 2 e ottenere 9. Vogliamo aumentare 5 alla potenza di 3 e ottenere 125.

Se l'input era 135, la stringa risultante è +1**1+3**2+5**3.

4. Flag di modifica del regex. Qui stiamo usando due flag regex - /ge /r. /gdice all'interprete di continuare le sostituzioni dopo che il primo è stato trovato (altrimenti finiremmo con +1**135). /rdice all'interprete di non modificare la stringa originale e restituisce invece quale sarebbe la stringa dopo le sostituzioni. Questo è importante, perché altrimenti sovrascriverebbe $_e ne abbiamo bisogno a fini comparativi.

Una volta effettuata l'intera sostituzione, otteniamo un'espressione matematica, che viene valutata con la evalfunzione. +1**1+3**2+5**3viene valutato in 1 + 9 + 125 = 135, che viene confrontato con il numero originale 135. Poiché questi due sono uguali, il codice stampa il numero.

JavaScript (ES7), 105 91 89 88 83 79 82 81 byte

Grazie ad Arnauld per il risparmio di 20 B e ETHProductions per il risparmio di 6 B!

a=>b=>[...Array(b).keys()].filter(c=>c>=a&([...c+''].map(d=>c-=d**++e,e=0),!c))

uso

Assegna la funzione a una variabile e assegnale il minimo e il massimo come argomenti. Esempio:

f=a=>b=>[...Array(b).keys()].filter(c=>c>=a&([...c+''].map(d=>c-=d**++e,e=0),!c))
f(0)(90)

Produzione

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 89]

Ulteriore golf

Sembra abbastanza ben golfato, ma c'è sempre spazio per miglioramenti ... Penso.

JavaScript (Firefox 52+), 68 byte

f=(n,m)=>(e=0,[for(d of t=n+'')t-=d**++e],t||alert(n),n-m&&f(n+1,m))

Funzione ricorsiva che emette via alert. Funziona nella Developer Edition di Firefox, che puoi scaricare in questa pagina . Le versioni precedenti di Firefox non supportano l' **operatore e nessun altro browser supporta la [for(a of b)c]sintassi.

Snippet di prova

Questo utilizza .mapinvece di una comprensione dell'array e Math.powinvece di **, quindi dovrebbe funzionare in tutti i browser che supportano ES6.

f=(n,m)=>(e=0,[...t=n+''].map(d=>t-=Math.pow(d,++e)),t||alert(n),n-m&&f(n+1,m))

f(0,100)

05AB1E , 12 byte

Salvato 2 byte grazie a Emigna

ŸvygLySmOyQ—

Provalo online!

Ÿ            # push [a .. b]
 vy          # for each
   gL        # push [1 .. num digits]
     yS      # push [individual digits]
       m     # push [list of digits to the power of [1..num digits] ]
        O    # sum
         yQ— # print this value if equal

Python 3, 100 byte

lambda n,m:{*range(10),89,135,175,518,598,1306,1676,2427,2646798,0xa8b8cd06890f2773}&{*range(n,m+1)}

Non l'approccio più breve, ma piuttosto carino. Ci sono finitamente molti disari; vedere la pagina OEIS per una bella prova. Questi sono tutti.

R, 100 byte

function(n,m,x=n:m)x[sapply(x,function(y)sum(as.integer(el(strsplit(c(y,""),"")))^(1:nchar(y)))==y)]

Funzione senza nome che accetta ne m. Come sempre in R, la divisione di numeri interi in un vettore di cifre numeriche è noiosa e consuma molti byte. Ciò rende la funzione relativamente lenta e funziona solo per numeri interi a 32 bit.

Gelatina , 11 byte

D*J$S⁼
rÇÐf

Provalo online!

Ho ottenuto questo risultato dalle 16 alle 11, con l'aiuto di @miles!

Spiegazione:

rÇÐf    Main link, arguments are m and n
r       Generate a list from m to n
 Ç      Invoke the helper link
  Ðf    And filter out all that don't return 1 on that link

D*J$S⁼  Helper link, determines if item is Disarium
D       Break input (the current item of our list in Main) into digits (135 --> [1, 3, 5])
  J$    Create a range from 1 to x, where x is the number of digits             [1, 2, 3]
 *      Raise each digit to the power of their respective index 
    S⁼  And return a 1 if the sum of powers is equal to the helper-link's input

CJam , 23 byte

q~),\>{_Ab_,,:).#:+=},p

Provalo online!

Spiegazione

q~                      Get and eval all input
  ),\>                  Get the range between m and n, inclusive
      {                 For each number in the range...
       _Ab               Duplicate and get the list of digits
          _,,:)          Duplicate the list, take its length, make the range from 1 to length
               .#        Vectorize with exponentiation; computes first digit^1, second^2, etc
                 :+      Sum the results
                   =     Compare to the original number
                    },  Filter the range to only numbers for which the above block is true
                      p Print nicely

05AB1E , 18 byte

Ÿvy©SDgLsmO®Qi®}})

Provalo online!

Python 2.X, 92 byte

lambda m,n:[k for k in range(m,n+1)if sum(int(j)**(i+1) for i,j in enumerate(list(`k`)))==k]

Python 2 , 84 byte

Un approccio al programma completo, attualmente della stessa lunghezza della soluzione lambda.

a,b=input()
while a<=b:
 t=p=0
 for x in`a`:p+=1;t+=int(x)**p
 if t==a:print a
 a+=1

Provalo online!

Japt, 15 byte

òV f_¥Zì £XpYÄÃx

Provalo online! Questa è stata una collaborazione tra @obarakon e me stesso.

Come funziona

òV f_¥Zì £XpYÄÃx   // Implicit: U, V = input integers
òV                 // Create the inclusive range [U...V].
   f_              // Filter to only the items Z where...
               x   //   the sum of
      Zì           //   the decimal digits of Z,
         £XpYÄÃ    //   where each is raised to the power of (index + 1),
     ¥             //   is equal to Z.
                   // Implicit: output result of last expression

Nell'ultima versione di Japt, xaccetta una funzione come argomento, che ci consente di giocare a golf un altro byte:

òV f_¥Zì x@XpYÄ

Provalo online!

Clojure, 107 byte

#(for[i(range %(inc %2)):when(=(int(apply +(map(fn[i v](Math/pow(-(int v)48)(inc i)))(range)(str i))))i)]i)

L'implementazione dell'equazione è terribilmente lunga.

TI-Basic, 85 byte

Input 
For(I,X,Y
If I<=9 or sum(I={89,135,175,518,598,1306,1676,2427,2646798,12157692622039623539
Disp I
End

Haskell, 61 byte

n#m=[i|i<-[n..m],i==sum(zipWith(^)(read.pure<$>show i)[1..])]

Esempio di utilizzo 5 # 600-> [5,6,7,8,9,89,135,175,518,598].

Controlla ogni numero inell'intervallo [n..m]. Le cifre vengono estratte trasformandosi iin una stringa ( show) e trasformando ogni carattere in una stringa di un elemento ( pure) che viene nuovamente trasformata in un numero intero ( read). Comprimi l'elemento saggio con [1..]la funzione ^e prendi il tasto sum.

PHP, 92 91 88 byte

3 byte salvati grazie a @AlexHowansky

for([,$n,$m]=$argv;$n<=$m;$s-$n++?:print"$s,")for($i=$s=0;_>$b=($n._)[$i++];)$s+=$b**$i;

accetta input dagli argomenti della riga di comando; stampa una virgola finale. Corri con -r.

Mathematica, 59 byte

Select[Range@##,Tr[(d=IntegerDigits@#)^Range@Length@d]==#&]&

Funzione senza nome che accetta due argomenti interi e restituisce un elenco di numeri interi. (d=IntegerDigits@#)^Range@Length@dproduce l'elenco delle cifre di un numero ai poteri appropriati; Tr[...]==#rileva se la somma di tali poteri numerici è uguale al numero originale.

MATLAB, 88 73 byte

@(n,m)find(arrayfun(@(n)n==sum((num2str(n)-48).^(1:log10(n)+1)),n:m))+n-1

Risposta originale:

function g(n,m);a=n:m;a(arrayfun(@(n)n==sum((num2str(n)-'0').^(1:floor(log10(n))+1)),a))

num2str(n)-'0'divide a nin un vettore delle sue cifre ed 1:floor(log10(n))+1è un vettore che ne tiene uno al numero di cifre n. Grazie per accedere al golf fino a una funzione anonima, risparmiando 15 byte.

Haskell , 82 76 75 byte

n!m=[x|x<-[n..m],x==x#(length.show)x]
0#i=0
n#i=(div n 10)#(i-1)+mod n 10^i

Provalo online! Uso:5 ! 175

Questo controlla ogni numero nell'intervallo ndi mse numero di disarium ed è quindi piuttosto lento per grande m.

Versione più veloce: (93 byte)

n!m=[x|x<-[0..9]++[89,135,175,518,598,1306,1676,2427,2646798,12157692622039623539],x>=n,x<=m]

Provalo online!

C (gcc) , 136 byte

r[]={0,0};f(n){if(n)f(n/10),r[1]=pow((n%10),*r)+r[1]+.5,r[0]++;else*r=1,r[1]=0;}g(m,x){for(;m<=x;m++){f(m);if(m==r[1])printf("%d,",m);}}

Intestazione che definisce pow su TIO perché per qualche motivo non includeva automaticamente pow. Lo ha fatto il mio computer, quindi ho intenzione di farlo.

Provalo online!

MATL , 16 byte

&:"@tFYAtn:^s=?@

Provalo online!

&:        % Input two n, m implicitly. Push array [n n+1 ... m]
"         % For each k in that array
  @       %   Push k
  tFYA    %   Duplicate. Convert to decimal digits
  tn:     %   Duplicate. Push [1 2 ... d], where d is the number of digits
  ^       %   Element-wise power
  s       %   Sum of array
  =       %   Compare with previous copy of k: is it equal?
  ?       %   If so
    @     %     Push k
          %   End, implicit
          % End, implicit
          % Display stack, implicit

Lotto, 115 byte

@for %%d in (0 1 2 3 4 5 6 7 8 9 89 135 175 518 598 1306 1676 2427 2646798)do @if %%d geq %1 if %%d leq %2 echo %%d

Il batch ha solo un'aritmetica a 32 bit che non ha modo di confrontare l'ultimo numero di disarium, ma se insisti sul confronto di stringhe, quindi per 402 byte:

@echo off
for %%d in (0 1 2 3 4 5 6 7 8 9 89 135 175 518 598 1306 1676 2427 2646798 12157692622039623539)do call:c %1 %%d&&call:c %%d %2&&echo %%d
exit/b
:c
call:p %1 %2
set r=%s%
call:p %2 %1
:g
if %r:~,1% lss %s:~,1% exit/b0
if %r:~,1% gtr %s:~,1% exit/b1
if %r%==%s% exit/b0
set r=%r:~1%
set s=%s:~1%
goto g
:p
set s=%1
set t=%2
:l
set s=0%s%
set t=%t:~1%
if not "%t%"=="" goto l

Python 2, 100 byte

for i in range(input(),input()+1):x=sum(int(`i`[n])**-~n for n in range(len(`i`)));print("",x)[x==i]

Non ho ancora avuto la possibilità di eseguirlo (farlo sul mio telefono).

Scala, 132 129 byte

(% :Int,^ :Int)=>for(i<- %to^)if(((0/:(i+"").zipWithIndex)((z,f)=>{z+BigInt(f._1.toInt-48).pow(f._2+1).intValue}))==i)println(i)

129 modifica: modifica del nome della variabile del ciclo for da &in itre spazi salvati.

Spiegazione

Per ciascun valore nell'intervallo di input:

• convertilo in una stringa con +""
• utilizzare zipWithIndexper produrre un elenco di tuple contenente un carattere della cifra e il suo indice
• piega l'elenco restituendo il valore int di ciascun carattere meno 48 (righe fino a 0-9) alla potenza del suo indice di elenco più uno (per iniziare da ^ 1)
• se il risultato corrisponde all'input, stamparlo

Commenti

Finalmente sono riuscito a imparare come folde come zipWithIndexlavorare. Non sono soddisfatto delle intconversioni, ma sono contento della succinta di folde zipWithIndex.

Ottava, 88 87 byte

Grazie a MattWH per aver salvato un byte (f (x) -48 vs f (x) - '0')

@(n,m,f=@num2str,a=n:m)a(a==cell2mat(arrayfun(@(x){sum((f(x)-48).^(1:nnz(f(x))))},a)))

Correre:

>> f=@(n,m,f=@num2str,a=n:m)a(a==cell2mat(arrayfun(@(x){sum((f(x)-'0').^(1:nnz(f(x))))},a))) 
>> f(0,1000)
ans = 
      1     2     3     4     5     6     7     8     9    89   135   175   518   598

Spiegazione

@(n,m,                                              % Create an anonymous function and pass it n and m as paramteres
    f=@num2str,                                     % Will be using the num2str mehtod twice, set the variable f to the handle to save on bytes
        a=n:m)                                      % Create a vector 'a' and populate it with the numbers n through m
            a(a==                                   % Logically index into a, where the values of a match Disarium numbers
                cell2mat(                           % Convert the cell array returned by arrayfun into a matrix, so we can use it in the logical index
                    arrayfun(@(x){                  % Call the following function on every element of a, using the index named 'x'
                        sum(                        % Sum the matrix that results from the following computation
                            (f(x)-'0')              % Convert the value at index x into a string, then break it into a matrix by subtracting the string '0'.
                                                    % This results in the matrix [1 3 5] for the number 135.
                                .^                  % Compute the element-wise power with the following matrix
                                    (1:nnz(f(x)))   % Create a matrix with the range 1 to the length of the number at index x. This results in the matrix 
                                                    % [1 2 3] for the number 135.
                        )                           % Closes the sum statement
                    },a)                            % Closes the arrayfun statement, passing the matrix a to be operated on
                )
            )

C 175 169 byte

f(a,b){for(j=a;j<b;j++){n,i=0,x=0;s=0;n=j;while(n!=0){n/=10;i++;}a[i];n=j;while(n!=0){a[i-x-1]=n%10;n/=10;x++;}for(x=0;x<i;x++)s+=(int)pow(a[x],x+1);if(j==s)printf("%d ",s);}}

Versione non golfata:

void f(int a, int b)
{

  for(int j=a; j<b;j++)
  {
    int n,i=0,x=0;
    int s=0;
    n=j;

   //Convert each number from 'n' to 'm' and store it in an int array 
   while(n)
   {
     n/=10;
     i++;     
   }
   int a[i]; 

   n=j;       
   while(n)
   {
    a[i-x-1]=n%10;
    n/=10;
    x++;     
   }

  //Calculate sum of digits powered with their respective position
  for(x=0;x<i;x++)
   s+=(int)pow(a[x], x+1);

   //Print Desarium
   if(j==s)
    printf("%d ", sum);     
 }

}

Può essere abbreviato in qualche modo, ma al momento non lo vedo.

@TuukkaX Grazie per aver salvato 6 byte.

Giava

s->{long i=0,j=0,c,d;for(;j!=s;){String []f=Long.toString(i).split("");for(d=0,c=0;d<f.length;)c+=Math.pow(Long.valueOf(f[d]),++d);if(i==c)j++;}return i;}

Spiegazione

s    - index
i    - iteration variable
j    - matches
c    - sum of each digit^its index
d    - index of digit in i

Python 3: 131 byte

n=int(input())
m=int(input())
R=[x for x in range(n,m+1)]
O=[sum(map(int,str(x)))for x in R]
F=[(x**(O.index(x)))for x in O]
L=[x for x in F for w in R if x==w]
print(list(set(L)))

Dopo aver creato questo codice, è diventato evidente che esiste un numero limitato di disari, quindi potrebbe essere più fattibile verificarli esplicitamente piuttosto che usare tanta comprensione dell'elenco che è dura per i grandi input di questa soluzione.

Provalo online!