Convergencia consecutiva repetida de suma de productos digitales

13

Dado un número entero positivo n( Ejemplo:n=1234444999 )

  • Separar en series de dígitos consecutivos:
    • [1, 2, 3, 4444, 999]
  • Tome el producto digital de cada carrera.
    • [1, 2, 3, 4*4*4*4, 9*9*9] = [1, 2, 3, 256, 729]
  • Sumalo ...
    • 991
  • Repita hasta que esto converja a un solo número:
    • 1234444999
    • 991
    • 82
    • 10
    • 1
  • Devuelve el último número.

Casos de prueba

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

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

Ejemplo solicitado:

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

¿Victorioso?

Es el código de golf , el conteo de bytes más bajo es el ganador.

code-golf  sequence 
— Urna de pulpo mágico
fuente
Annnnnnnnnnnnnnnnnnnd ... este NO es el sandbox. Mierda. Bueno, no puedo hacer mucho ahora, lo siento todo ._.
— Magic Octopus Urn
11
Sería bueno tener casos de prueba donde los dígitos del mismo tipo no estén todos en una porción consecutiva.
— xnor
1
¿Podemos tomar la entrada como una lista de dígitos? Algunos idiomas no pueden soportar enteros tan altos como 11122233344455566677788899.
— ETHproductions
@ETHproductions puede indicar la entrada entera máxima permitida por su idioma y hacer que su respuesta sea válida si puede explicar el límite.
— Magic Octopus Urn
44
¿Aparecerá el mismo dígito en 2 ejecuciones diferentes, por ejemplo 33445555666333:?
— Sr. Xcoder

Respuestas:

5

Jalea, 9 bytes

DŒgP€SµÐL

Pruébalo en línea

Así es 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ý
fuente
¿Por qué P no se vectoriza automáticamente? Eso parece extraño ...
— Esolanging Fruit
No, P se vectoriza automáticamente, por lo que no necesita el €.
— Esolanging Fruit
— Zacharý
Ah, ya veo, Œges inconsistente cuando solo hay un grupo. ¿Cuál es el razonamiento detrás de eso?
— Esolanging Fruit
¡Ni idea!
— Zacharý
5

Mathematica, 55 42 bytes

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

-13 bytes de @JungHwan Min . Gracias!

en caso de que alguien quiera usar esto como un generador de dígitos aleatorios,
aquí está el recuento de los primeros 100.000 números

{{1, 17320}, {2, 4873}, {3, 10862}, {4, 11358}, {5, 10853}, {6, 9688}, {7, 11464}, {8, 10878}, { 9, 12704}}
o si juegas, ¡no pongas tu dinero en 2!

— J42161217
fuente
5

Japt , 17 15 13 bytes

e".+"_¬ò¦ x_×

¡Pruébalo en línea! Toma la entrada como una cadena.

Todavía no estoy satisfecho con esta respuesta ...

Explicación

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
fuente
También puede tomarlo como un entero y establecer la entrada máxima permitida, lo siento, cambié mi respuesta después de publicarla en mi respuesta predeterminada para esa pregunta.
— Magic Octopus Urn
@MagicOctopusUrn Oh, hola, gracias. De todos modos, eso ahorra dos bytes ...
— ETHproductions
1
Además, la x_×combinación con I'm unsatisfiedme hizo reír. Gracias ;).
— Magic Octopus Urn
Pensé que ßpodría haber sido el camino a seguir aquí. ¡Estaba equivocado! (¡Al menos a las cinco y media de la mañana, me senté en el autobús al aeropuerto que estaba!)
— Shaggy
"Todavía no estoy satisfecho" ... así que ... ¿estás satisfecho finalmente?
— Zacharý
4

Brachylog , 8 bytes

Ḋ|ẹḅ×ᵐ+↰

Pruébalo en línea!

Explicación

Ḋ          Input = Output = a digit
 |         Or
  ẹ        Split into a list of digits
   ḅ       Group consecutive equal elements together
    ×ᵐ     Map multiply
      +    Sum
       ↰   Recursive call
— Fatalizar
fuente
Nunca esperarías que Brachylog superase a Jelly aquí, ¿verdad?
— Erik the Outgolfer
@EriktheOutgolfer Cuando Brachylog vence a Jelly, mi primera suposición es que la respuesta de Jelly no es óptima
— Fatalize
La mía también, excepto que también intenté hacer esto en Jelly. La cuestión es que, bueno, 05AB1E aún supera esto. :)
— Erik the Outgolfer
Bien. es un byte, y la respuesta de Jelly es mía, sí, esperaría que Brachylog venciera a Jelly.
— Zacharý
2

Casco , 8 bytes

ωöṁΠgmis

Toma y devuelve un entero. Pruébalo en línea!

Explicación

Tener un incorporado para 10 dígitos base sería bueno ...

ωöṁΠ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
fuente
2

JavaScript (ES6), 77 73 67 65 bytes

Guardado 2 bytes gracias a @CraigAyre

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

¿Cómo?

La entrada s se transforma en una expresión aritmética con:

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

Por ejemplo, se 1234444999convierte +1+2+3+4*4*4*4+9*9*9.

Evaluamos esta expresión y hacemos una llamada recursiva con el resultado hasta que se reduzca a un solo dígito decimal.

Casos de prueba

Mostrar fragmento de código

— Arnauld
fuente
Can you save a couple of bytes by comparing against 9?: f=s=>s>9?f(''+eval(s.replace(/(.)\1*/g,s=>'+'+[...s].join`*`))):s
— Craig Ayre
@CraigAyre Seems like my approach was a bit overcomplicated indeed. Thanks!
— 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

reads from stdin; returns the answer as a string.

Try it online!

— Giuseppe
fuente
Podrías usar en pastelugar de as.character. El primero coacciona su entrada en charactertipo ;-)
— Frédéric
1

MATL, 11 bytes

`!UY'^sVtnq

Pruébalo en MATL Online

Explicación

        % 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
fuente
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

Enfoque ligeramente diferente a la otra respuesta usando R.

Esta respuesta hace uso de la rlefunción, quecompute[s] the lengths and values of runs of equal values in a vector .

-1 bytes gracias a @Giuseppe!

— Frédéric
fuente
1
**es equivalente a^
— Giuseppe
1

Braingolf, 25 bytes

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

Agregaré un enlace TIO una vez que haga que Dennis obtenga la última versión, ya que el uso de operadores codiciosos dentro de los (...)bucles está actualmente roto en TIO

Explicación

!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
fuente
1

Japt , 19 bytes

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

Pruébalo en línea!

Explicación:

=ò¦ 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
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.