17

Echa un vistazo a la tabla de multiplicar sietes de 7 × 0 a 7 × 9:

0, 7, 14, 21, 28, 35, 42, 49, 56, 63

Si solo miramos los dígitos en su lugar, obtenemos una permutación de los dígitos del 0 al 9:

0, 7, 4, 1, 8, 5, 2, 9, 6, 3

Considere tomar un número entero decimal positivo N y reemplazar cada dígito D en N con el dígito en el lugar de 7 × D.

Por ejemplo, 15209se hace 75403porque 1se asigna a 7, 5mapas para 5, 2mapas para 4, 0mapas para 0, y 9se asigna a 3.

Ahora repitamos este proceso con este nuevo entero decimal hasta que veamos un ciclo, es decir, hasta que aparezca un entero que ya hemos visto.

Por ejemplo, con 15209nosotros obtenemos el ciclo

15209 -> 75403 -> 95801 -> 35607 -> 15209 -> repeats...
                                      ^
                                      |
                             cycle restarts here

Como otro ejemplo, 505tiene el ciclo corto

505 -> 505 -> repeats...
        ^
        |
cycle restarts here

Resulta que para cualquier N estos ciclos siempre contendrán exactamente 1 o 4 enteros distintos. (Dejaré que usted descubra por qué es eso). Lo interesante es que si suma todos los enteros distintos en un ciclo, casi siempre obtiene un entero decimal que solo consiste en 2'sy 0' s.

Por ejemplo, 15209 + 75403 + 95801 + 35607 = 222020.

N = 505 es una de las excepciones. El único entero en el ciclo es 505, por lo que la suma total es 505 en sí misma.

Aquí están las sumas de los ciclos para N = 1 a 60:

Llamaremos a esto la secuencia de la suma del ciclo de los siete.

Desafío

Escriba un programa o función que tome un entero decimal positivo N e imprima o devuelva, en decimal, el término correspondiente de la secuencia de la suma del ciclo de los siete.

Por ejemplo, si la entrada es 95801, la salida debería ser 222020. Si la entrada es 505, la salida debería ser 505. Si la entrada es 54, la salida debería ser 220.

El código más corto en bytes gana.

— Pasatiempos de Calvin
fuente

1

Por supuesto, si tomas los números de un ciclo y los multiplicas por cuatro, verás que todos ellos dan números cuyos únicos dígitos son 2 y 0.

— Peter Taylor

1

Pyth, 14 bytes

s.uieM*R7jNTTQ

No estoy seguro, por qué todos determinan el resultado al observar patrones en los números. Simplemente haciendo el proceso, calcular todos los números del círculo y resumirlos es más corto. Al menos en Pyth ;-)

Pruébelo en línea: Demostración o conjunto de pruebas

Por cierto, esta es mi 200a respuesta de código de golf. Así que esta publicación me gana la insignia de golf de código dorado.

Explicación:

s.uieM*R7jNTTQ   implicit: Q = input number
 .u          Q   apply the following expression to N=Q until it reaches a circle
         jNT        convert N to base 10
      *R7           multiply each digit with 7
    eM              and perform modulo 10 for each number
   i        T       convert digits from base 10 to a number
                    update N
                 .u returns the list of all intermediate results of N, 
                 so we have now all numbers of the circle
s                sum them up

— Jakube
fuente

Código ... espera ... golf! :) Felicidades, y buen uso de.u

— FryAmTheEggman

6

Python 2, 69 bytes

lambda n:[''.join('02'[x>'0']for x in`n`)+'0',n][set(`n`)<=set('05')]

La función es simple de describir:

Si n consta de solo 0 y 5, déjelo sin cambios.
De lo contrario, reemplace cada dígito de n con 2, excepto que 0 permanece 0, y agregue un 0 hasta el final.

El golf se puede mejorar, principalmente publico para compartir el método. Un lenguaje con expresiones regulares nativas debería permitir una solución corta.

Una declaración alternativa de la función es

En n, reemplace cada dígito con un 5, excepto que 0 permanece como 0
Si esto cambió n (tenía un dígito distinto de 0 o 5), multiplique el resultado por 4

— xnor
fuente

4

Python 2, 63 bytes

lambda s:s.strip('05')and''.join(`(c>'0')*2`for c in s)+'0'or s

Se espera que el argumento de entrada sea una cadena.

— Feersum
fuente

1

Wow, no tenía idea de stripcomportarse de esta manera.

— xsot

¡Vamos, las conversiones de tipo (string & harr; number) son una parte sustancial de la diversión (es decir, la longitud del código; o)!

— Charlie

4

CJam, 16 bytes

Usando el mismo algoritmo que todos los demás:

r_50s-{:~2fe&0}&

Banco de pruebas. (Genera todos los resultados desde 1 a la entrada).

Explicación

r_      e# Read input and duplicate
50s     e# Push the string "50".
-       e# Remove all '5' and '0' characters from the input.
{       e# If any characters remained in the input...
  :~    e#   Evaluate each digit character to turn it into an integer.
  2fe&  e#   Map (&& 2) over the list. Due to short-circuiting, zeros remain zeros and
        e#   everything else becomes 2.
  0     e#   Push a trailing zero.
}&

— Martin Ender
fuente

3

JavaScript (ES6), 54 51 bytes

Usando el método de xnor :

n=>/[^05]/.test(n)?`${n}0`.replace(/./g,d=>+d&&2):n

Guardado 3 bytes gracias a @charlie !

Explicación

n=>
  (s=n+"").match`[^05]`          // if there are any digits which aren't 5 or 0
    ?s.replace(/\d/g,d=>+d&&2)+0 //     replace every digit except 0 with 2 then add a 0
  :s                             // else return the input unchanged

Prueba

Mostrar fragmento de código

<input type="number" id="input" value="0" oninput='result.textContent=(

n=>(s=n+"").match`[^05]`?s.replace(/\d/g,d=>+d&&2)+0:s

)(+input.value)' />
<pre id="result"></pre>

Expandir fragmento

Método ingenuo, 102 bytes

n=>(c=x=>~r.indexOf(x+=m="")?eval(r.join`+`):[...r[++i]=x].map(d=>m+="0741852963"[d])&&c(m))(n,i=r=[])

n=>
  (c=x=>                  // c = recursive function
    ~r.indexOf(           // if we have calculated this number before
      x+=m="")?           // cast x to a string, m = calculated result
        eval(r.join`+`):  //     return the sum of all the calculated numbers
    [...r[++i]=x].map(d=> // else add x to the list of calculated numbers
      m+="0741852963"[d]  // map each digit of x to the "seven" digits
    )&&c(m)               // calculate the value of the result
  )(n,i=r=[])             // r = array of previously calculated values

Mostrar fragmento de código

<input type="number" id="input" value="0" oninput='result.textContent=(

n=>(c=x=>~r.indexOf(x+=m="")?eval(r.join`+`):[...r[++i]=x].map(d=>m+="0741852963"[d])&&c(m))(n,i=r=[])

)(+input.value)' />
<pre id="result"></pre>

Expandir fragmento

— usuario81655
fuente

51 bytes:n=>/[^05]/.test(n)?`${n}0`.replace(/./g,d=>+d&&2):n

— charlie

1

40 bytes:n=>n-(s=`${n}`.replace(/[^0]/g,5))?s*4:n

— charlie

1

@charlie Wow, ¡ese s*4truco es increíble! Creo que debe publicar esto como una respuesta separada porque el método es lo suficientemente diferente y es mucho más corto que el mío. :)

— user81655

ok, humildemente lo haré; o)

— Charlie

2

Mathematica, 83 77 60 caracteres

Tr@Union@NestList[FromDigits@Mod[7IntegerDigits@#,10]&,#,4]&

Sin golf

Tr@
  Union@
   NestList[
    FromDigits@Mod[7 IntegerDigits@#, 10] &,
    #,
    4
   ] &

— shrx
fuente

2

JavaScript (ES5), 40 bytes

n=>(s=`${n}`.replace(/[^0]/g,5))^n?s*4:n

Es una evolución de la solución usuario 81655 , utilizando el enfoque alternativo descrito por xnor .

Explicación

La suma de un dígito distinto de cero en el ciclo 4 siempre es 20, ya que el dígito se desplaza por 1 → 7 → 9 → 3, o 2 → 4 → 8 → 6, o 5 → 5 → 5 → 5. Por lo tanto, reemplazar cada dígito con 5 no cambia la suma.

Esa acción de reemplazo se reutiliza para distinguir el ciclo 4 de 1 ciclo: si el resultado del reemplazo es diferente de la entrada, entonces es un ciclo 4, de lo contrario es un ciclo 1.

NB: La cadena de plantilla `${n}`es solo para facilitar la lectura, (n+'')tiene la misma longitud.

— Charlie
fuente

no regexp - 47 bytes:n=>(s=[...`${n}`].map(d=>+d&&5).join``)^n?s*4:n

— charlie

0

sed, 26 bytes

/[^05]/{s/[^0]/2/g;s/$/0/}

(Otra versión del enfoque "reemplazar por 2").

Ejemplos

echo '500' | sed '/[^05]/{s/[^0]/2/g;s/$/0/}' → 500

echo '501' | sed '/[^05]/{s/[^0]/2/g;s/$/0/}' → 2020

— Charlie
fuente

0

Perl 6 , 68 55 53 36 33 bytes

{[+] $^a,{[~] $^b.comb.map: {'0741852963'.comb[$_]}}...^{$++*?/$a/}} # 68

{$_=@=$_.comb;[~] (@$_,(|.map(2*?+*),0))[$_⊈qw<0 5>]} # 55

{[~] ($_=@=$_.comb)⊆qw<0 5>??@$_!!(|.map(2*?+*),0)} # 53

{/^<[05]>+$/??$_!!S:g/./{2*?+$/}/~0} # 36

{m/^<[05]>+$/||S:g/./{2*?+$/}/~0} # 33

Definitivamente, esta es la forma incorrecta de hacer esto, si el número consiste solo en 5sys 0, devolverá un objeto Match, de lo contrario, reemplazará todo menos 0con a 2, y agregará 0a al final.
(El objeto Match se comportará como un número si lo usa como uno)

Aunque como lo está haciendo mal, es fácil señalar los números raros llamando al gist método.

uso:

# give it a name
my &code = {...}

.say for (0..60,505,15209).flat.map({ code($_).gist.fmt: '%4s' }).rotor(1,10 xx 6,:partial)

( ｢0｣)
(  20   20   20   20  ｢5｣   20   20   20   20  200)
( 220  220  220  220  220  220  220  220  220  200)
( 220  220  220  220  220  220  220  220  220  200)
( 220  220  220  220  220  220  220  220  220  200)
( 220  220  220  220  220  220  220  220  220 ｢50｣)
( 220  220  220  220 ｢55｣  220  220  220  220  200)
(｢505｣)
(222020)

— Brad Gilbert b2gills
fuente

Secuencia de suma del ciclo de siete

Desafío

Pyth, 14 bytes

Explicación:

Python 2, 69 bytes

Python 2, 63 bytes

CJam, 16 bytes

Explicación

JavaScript (ES6), 54 51 bytes

Explicación

Prueba

Método ingenuo, 102 bytes

Mathematica, 83 77 60 caracteres

JavaScript (ES5), 40 bytes

Explicación

sed, 26 bytes

Ejemplos

Perl 6 , 68 55 53 36 33 bytes