17

Jetez un oeil à la table de multiplication de sept de 7 × 0 à 7 × 9:

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

Si nous regardons simplement les chiffres à sa place, nous obtenons une permutation des chiffres de 0 à 9:

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

Envisagez de prendre un nombre décimal positif N et de remplacer chaque chiffre D dans N par le chiffre à la place de 7 × D.

Par exemple, 15209devient 75403parce que 1correspond à 7, 5correspond à 5, 2correspond à 4, 0correspond à 0et 9correspond à 3.

Maintenant, répétons ce processus avec ce nouvel entier décimal jusqu'à ce que nous voyions un cycle, c'est-à-dire jusqu'à ce qu'un entier que nous avons déjà vu apparaisse.

Par exemple, avec 15209nous obtenons le cycle

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

Comme autre exemple, 505le cycle court

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

Il s'avère que pour tout N, ces cycles contiendront toujours exactement 1 ou 4 entiers distincts. (Je vous laisse le soin de comprendre pourquoi.) Ce qui est intéressant, c'est que si vous additionnez tous les entiers distincts dans un cycle, vous obtenez presque toujours un entier décimal qui se compose uniquement de 2'et 0'.

Par exemple, 15209 + 75403 + 95801 + 35607 = 222020.

N = 505 est l'une des exceptions. Le seul entier du cycle est 505, la somme totale est donc 505 elle-même.

Voici les sommes des cycles pour N = 1 à 60:

Nous appellerons cela la séquence de somme du cycle des sept.

Défi

Écrivez un programme ou une fonction qui prend un entier décimal positif N et imprime ou renvoie, en décimal, le terme correspondant de la séquence de somme du cycle de sept.

Par exemple, si l'entrée est 95801, la sortie doit l'être 222020. Si l'entrée est 505, la sortie devrait l'être 505. Si l'entrée est 54, la sortie devrait l'être 220.

Le code le plus court en octets gagne.

— Loisirs de Calvin
source

1

Bien sûr, si vous prenez les nombres des cycles uniques et les multipliez par quatre, vous constaterez que tous donnent des nombres dont les seuls chiffres sont 2 et 0.

— Peter Taylor

1

Pyth, 14 octets

s.uieM*R7jNTTQ

Je ne sais pas, pourquoi tout le monde détermine le résultat en regardant les modèles dans les chiffres. Faire simplement le processus, calculer tous les nombres du cercle et les additionner est plus court. Au moins en Pyth ;-)

Essayez-le en ligne: démonstration ou suite de tests

Btw, ceci est ma 200e réponse de code-golf. Donc, ce poste me vaut le badge Gold-golf.

Explication:

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
source

Code ... attends ... golf! :) Félicitations et bonne utilisation de.u

— FryAmTheEggman

6

Python 2, 69 octets

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

La fonction est simple à décrire:

Si n se compose uniquement de 0 et de 5, sortez-le inchangé.
Sinon, remplacez chaque chiffre de n par 2, sauf que 0 reste 0 et clouez un 0 jusqu'à la fin.

Le golf peut être amélioré, je poste principalement pour partager la méthode. Une langue avec regex native devrait permettre une solution courte.

Une autre déclaration de la fonction est

Dans n, remplacez chaque chiffre par un 5, sauf que 0 reste à 0
Si cela a changé n (il avait un chiffre autre que 0 ou 5), multipliez le résultat par 4

— xnor
source

4

Python 2, 63 octets

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

L'argument d'entrée devrait être une chaîne.

— feersum
source

1

Wow, je n'avais aucune idée de stripce comportement.

— xsot

Allez, les conversions de type (string & harr; number) sont une partie importante du plaisir (c'est-à-dire la longueur du code; o)!

— charlie

4

CJam, 16 octets

En utilisant le même algorithme que tout le monde:

r_50s-{:~2fe&0}&

Suite de tests. (Génère tous les résultats de 1 à l'entrée.)

Explication

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
source

3

JavaScript (ES6), 54 51 octets

En utilisant la méthode de xnor :

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

Sauvegardé 3 octets grâce à @charlie !

Explication

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

Tester

Afficher l'extrait de code

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

Développer l'extrait

Méthode naïve, 102 octets

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

Afficher l'extrait de code

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

Développer l'extrait

— user81655
source

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

— charlie

1

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

— charlie

1

@charlie Wow, ce s*4truc est génial! Je pense que vous devriez poster ceci comme une réponse séparée car la méthode est suffisamment différente et elle est tellement plus courte que la mienne. :)

— user81655

ok, je le ferai humblement; o)

— charlie

2

Mathematica, 83 77 60 caractères

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

Non golfé

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

— shrx
source

2

JavaScript (ES5), 40 octets

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

C'est une évolution de la solution de user81655 , en utilisant l'approche alternative décrite par xnor .

Explication

La somme d'un chiffre non nul dans le cycle 4 est toujours de 20, car le chiffre passe par 1 → 7 → 9 → 3, ou 2 → 4 → 8 → 6, ou 5 → 5 → 5 → 5. Donc, remplacer chacun de ces chiffres par 5 ne change pas la somme.

Cette action de remplacement est réutilisée pour distinguer le cycle 4 du cycle 1 - si le résultat du remplacement est différent de l'entrée, alors c'est un cycle 4, sinon c'est un cycle.

NB: La chaîne du modèle `${n}`est juste pour la lisibilité, (n+'')a la même longueur.

— Charlie
source

pas d'expression régulière - 47 octets:n=>(s=[...`${n}`].map(d=>+d&&5).join``)^n?s*4:n

— charlie

0

sed, 26 octets

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

(Un autre point de vue sur l'approche "remplacer par 2".)

Exemples

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

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

— Charlie
source

0

Perl 6 , 68 55 53 36 33 octets

{[+] $^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

C'est certainement la mauvaise façon de procéder, si le nombre est composé uniquement de 5s et 0s, il retournera un objet Match, sinon il remplace tout sauf 0par un 2, et ajoute un 0à la fin.
(L'objet Match se comportera comme un nombre si vous l'utilisez comme un seul)

Bien que comme il le fait mal, il est facile de signaler les rares numéros en appelant la gistméthode.

usage:

# 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
source

Séquence de somme du cycle de sept

Défi

Pyth, 14 octets

Explication:

Python 2, 69 octets

Python 2, 63 octets

CJam, 16 octets

Explication

JavaScript (ES6), 54 51 octets

Explication

Tester

Méthode naïve, 102 octets

Mathematica, 83 77 60 caractères

JavaScript (ES5), 40 octets

Explication

sed, 26 octets

Exemples

Perl 6 , 68 55 53 36 33 octets