Convergência de soma consecutiva consecutiva de produtos digitais

13

Dado um número inteiro positivo n( Exemplo:n=1234444999 )

  • Separe em execuções consecutivas de dígitos:
    • [1, 2, 3, 4444, 999]
  • Pegue o produto digital de cada execução.
    • [1, 2, 3, 4*4*4*4, 9*9*9] = [1, 2, 3, 256, 729]
  • Soma isso ...
    • 991
  • Repita até que isso converja para um único número:
    • 1234444999
    • 991
    • 82
    • 10
    • 1
  • Retorna o último número.

Casos de teste

BASE CASES:
0 = 0
...
9 = 9

OTHER CASES:
1234444999                     = 1
222222222222222                = 8
111222333444555666777888999000 = 9
11122233344455566677788899     = 8
1112223334445                  = 6
14536                          = 1
99                             = 9

Exemplo solicitado:

334455553666333
9+16+625+3+216+27
896
8+9+6
23
2+3
**5**

Ganhando?

É código-golfe , o menor número de bytes é o vencedor.

code-golf  sequence 
— Urna de polvo mágico
fonte
Annnnnnnnnnnnnnnnnnd ... essa NÃO é a caixa de areia. Porcaria. Bem, não posso fazer muito agora, desculpe a todos ._.
— Magia Octopus Urna
11
Seria bom ter casos de teste em que dígitos do mesmo tipo não estejam todos em um pedaço consecutivo.
— Xnor
1
Podemos considerar a entrada como uma lista de dígitos? Alguns idiomas não podem suportar números inteiros tão altos quanto 11122233344455566677788899.
— ETHproductions
@ETHproductions, você pode indicar a entrada máxima máxima permitida pelo seu idioma e ter sua resposta válida se puder explicar os limites.
— Magia Octopus Urna
4
O mesmo dígito será exibido em 2 execuções diferentes, por exemplo 33445555666333:?
— Mr. Xcoder

Respostas:

5

Geléia, 9 bytes

DŒgP€SµÐL

Experimente online

Veja como funciona:

D  - input as a list of digits
Œg - group runs of equal elements
P€ - the product of each element
S  - the sum of the list
µ  - syntax stuff to separate the left from the right
ÐL - repeat until we get a result twice, then return that result.
— Zacharý
fonte
Por que P não vetoriza automaticamente? Isso parece estranho ...
— Esolanging Fruit
Não, P vetoriza automaticamente, assim você não precisa do €.
— Esolanging Fruit
— Zacharý
Ah, entendo - Œgé inconsistente quando há apenas um grupo. Qual é o raciocínio por trás disso?
— Esolanging Fruit
Nenhuma pista!
— Zacharý
5

Mathematica, 55 42 bytes

#//.i_:>Tr[Times@@@Split@IntegerDigits@i]&

-13 bytes de @JungHwan min . Thanx!

caso alguém queira usar isso como um gerador de dígitos aleatórios,
eis a contagem dos primeiros 100.000 números

{{1, 17320}, {2, 4873}, {3, 10862}, {4, 11358}, {5, 10853}, {6, 9688}, {7, 11464}, {8, 10878}, { 9, 12704}}
ou, se você jogar, não coloque o seu dinheiro em 2!

— J42161217
fonte
5

Japonês , 17 15 13 bytes

e".+"_¬ò¦ x_×

Teste online! Recebe a entrada como uma sequência.

Ainda não está satisfeito com esta resposta ...

Explicação

e".+"_  ¬ ò¦  x_  ×
e".+"Z{Zq ò!= xZ{Zr*1}}

e".+"                     Repeatedly replace all matches of /.+/ (the entire string)
     Z{               }   Z with this function:
       Zq                   Split Z into chars.
          ò!=               Partition at inequality; that is, split into runs of equal items.
              xZ{    }      Take the sum of: for each item in Z:
                 Zr*1         the item reduced by multiplication (i.e. the product).
                          This procedure is repeated until the same result is yielded twice.
                          Implicit: output result of last expression
— ETHproductions
fonte
Você também pode considerá-lo um número inteiro e indicar a entrada máxima permitida. Desculpe, mudei minha resposta depois de postá-la na minha resposta padrão para essa pergunta.
— Magic Octopus Urn
@MagicOctopusUrn Oh, ei, obrigado. Isso economiza dois bytes, enfim ...
— ETHproductions
1
Além disso, o x_×combinado com I'm unsatisfiedme fez rir. Obrigado ;).
— Magic Octopus Urn
Eu pensei que ßpoderia ter sido o caminho a percorrer aqui. Eu estava errado! (Pelo menos a metade 5 da manhã', sentou-se no autocarro para o aeroporto I foi!)
— Shaggy
"Ainda não está insatisfeito" ... então ... você está finalmente satisfeito?
— Zacharý
4

Braquilog , 8 bytes

Ḋ|ẹḅ×ᵐ+↰

Experimente online!

Explicação

Ḋ          Input = Output = a digit
 |         Or
  ẹ        Split into a list of digits
   ḅ       Group consecutive equal elements together
    ×ᵐ     Map multiply
      +    Sum
       ↰   Recursive call
— Fatalizar
fonte
Você nunca esperaria que Brachylog superasse Jelly aqui, esperaria?
— Erik the Outgolfer
@EriktheOutgolfer Quando Brachylog bate Jelly, minha primeira suposição é que a resposta Jelly não é o ideal
— Fatalize
O meu também, exceto que tentei fazer isso no Jelly também. O problema é que, bem, o 05AB1E ainda supera isso. :)
— Erik the Outgolfer
Bem. é um byte, e a resposta Jelly é minha, sim, eu esperaria que Brachylog vencesse Jelly.
— Zacharý 12/07/19
2

Casca , 8 bytes

ωöṁΠgmis

Pega e retorna um número inteiro. Experimente online!

Explicação

Ter um built-in para a base 10 dígitos seria bom ...

ωöṁΠgmis
ω         Iterate until a fixed point is found
 ö        the composition of the following four functions:
       s   convert to string,
     mi    convert each digit to integer,
    g      group equal adjacent integers,
  ṁΠ       take product of each group and sum the results.
— Zgarb
fonte
2

JavaScript (ES6), 77 73 67 65 bytes

Guardado 2 bytes graças a @CraigAyre

f=s=>s>9?f(''+eval(s.replace(/(.)\1*/g,s=>'+'+[...s].join`*`))):s

Quão?

A entrada s é transformada em uma expressão aritmética com:

s.replace(/(.)\1*/g, s => '+' + [...s].join`*`)

Por exemplo, 1234444999torna-se +1+2+3+4*4*4*4+9*9*9.

Avaliamos essa expressão e fazemos uma chamada recursiva com o resultado até que se reduza a um único dígito decimal.

Casos de teste

Mostrar snippet de código

— Arnauld
fonte
Você pode salvar um par de bytes, comparando contra 9 ?:f=s=>s>9?f(''+eval(s.replace(/(.)\1*/g,s=>'+'+[...s].join`*`))):s
— Craig Ayre
@CraigAyre Parece que minha abordagem foi um pouco complicada demais. Obrigado!
— Arnauld
1

R , 114 104 bytes

n=scan(,'');while(nchar(n)>1){n=el(strsplit(n,''));b=table(n);n=as.character(sum(strtoi(names(b))^b))};n

lê de stdin; retorna a resposta como uma sequência.

Experimente online!

— Giuseppe
fonte
Você poderia usar em pastevez de as.character. Os ex-coage sua entrada charactertipo ;-)
— Frédéric
1

MATL, 11 bytes

`!UY'^sVtnq

Experimente no MATL Online

Explicação

        % Implicitly grab input as a string
`       % Do...while loop
  !U    % Convert the string to an array of numbers (the digits)
  Y'    % Perform run-length encoding
  ^     % Raise the digits to the power corresponding to the number of times they
        % occurred consecutively
  s     % Sum the result
  V     % Convert to a string
  tn    % Duplicate and determine the number of characters in the string
  q     % Subtract one, causes the loop to continue until it's a single digit
        % Implicit end of do...while loop and display
— Suever
fonte
1

R, 97 96 bytes

a=scan(,"");while(nchar(a)>1){a=paste(sum(strtoi((b<-rle(el(strsplit(a,""))))$v)^strtoi(b$l)))}a

Abordagem um pouco diferente do que a outra resposta usando R .

Esta resposta faz uso da rlefunção, qual compute[s] the lengths and values of runs of equal values in a vector.

-1 bytes graças a @ Giuseppe!

— Frédéric
fonte
1
**é equivalente a^
— Giuseppe
1

Braingolf, 25 bytes

!L1-Mv[RG(d&*)&+!L1-Mv>]R

Adicionarei um link do TIO assim que o Dennis puxar a versão mais recente, pois o uso de operadores gananciosos dentro de (...)loops está quebrado no TIO

Explicação

!L1-Mv[RG(d&*)&+!L1-Mv>]R  Implicit input from commandline args
!L1-M                      Push length of input minus 1 to stack2
     v                     Switch to stack2
      [.........!L1-Mv>]   While length of input > 1..
       RG                  Split into digit runs
         (d&*)             Product of digits of each item in stack
              &+           Sum stack
                        R  Return to stack1
                           Implicit output from stack
— Skidsdev
fonte
1

Japonês , 19 bytes

=ò¦ m¬®×Ãx)<A?U:ßUs

Experimente online!

Explicação:

=ò¦ m¬®×Ãx)<A?U:ßUs
=                    // Implicit U (input) =
 ò¦                  //   Split the input into an array of consecutive digit runs
    m¬               //   Split each inner array: ["1","22","333"] -> [["1"],["2","2"],["3","3","3"]]
      ®              //   Map; At each item:
       ×             //     Get the product of each run
        Ã            //   }
         x           //   Sum
           <A        // <10
             ?       // If true:
              U      //   return U
               :     // Else:
                ß    //   Run the program again; Pass:
                 Us  //     U, cast to a string
— Oliver
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.