Quand j'étais enfant et que je voulais compter les billets d'un dollar dans mes économies, j'ai compté à voix haute:

un deux trois quatre cinq six sept huit neuf dix;
onze, douze, treize, quatorze, quinze, seize, dix-sept, dix-huit, dix-neuf, vingt;
vingt et un, vingt-deux, vingt-trois, vingt-quatre, vingt-cinq ...

Finalement, j'en ai eu marre de prononcer chacun de ces nombres à plusieurs syllabes. Étant d'esprit mathématique, j'ai créé une méthode de comptage beaucoup plus efficace:

un deux trois quatre cinq six sept huit neuf dix;
un, deux, trois, quatre, cinq, six, sept, huit, neuf, vingt;
un, deux, trois, quatre, cinq, six, sept, huit, neuf, trente ...

Comme vous pouvez le constater, je ne prononcerais que le ou les chiffres qui ont changé par rapport au numéro précédent. Cela présente l’avantage supplémentaire qu’il est considérablement plus répétitif que les noms anglais des nombres, et qu’il nécessite donc moins de réflexion pour le calcul.

Défi

Ecrivez un programme / fonction qui prend un entier positif et affiche / retourne comment je le compterais: c’est-à-dire le chiffre non nul le plus à droite et tous les zéros à la fin.

Exemples

   1    1
   2    2
  10   10
  11    1
  29    9
  30   30
  99    9
 100  100
 119    9
 120   20
 200  200
 409    9
1020   20

Une liste complète des cas de test ne devrait pas être nécessaire. C'est A274206 sur OEIS.

Règles

• Votre entrée doit théoriquement fonctionner pour tous les entiers positifs, en ignorant les problèmes de précision et de mémoire.
• L'entrée et la sortie doivent être en décimal.
• Vous pouvez choisir de prendre en entrée et / ou en sortie un nombre, une chaîne ou un tableau de chiffres.
• L'entrée est garantie d'être un entier positif. Votre entrée peut faire n'importe quoi pour une entrée invalide.

C'est le code-golf , donc le code le plus court en octets gagne.

Python 2 , 28 octets

f=lambda n:n%10or 10*f(n/10)

Essayez-le en ligne!

Une formule récursive fonctionne très proprement. Si le dernier chiffre est différent de zéro, indiquez-le. Sinon, supprimez le zéro final, calculez le résultat et multipliez-le par 10.

Gelée , 6 3 octets

-3 octets en ayant les E / S sous forme de liste décimale de chiffres .

ṫTṪ

Suite de test sur Essayez-le en ligne!

Comment?

ṫTṪ - Main link: listOfDigits  e.g.  [1,    0,    2,    0]  or [1,      1,    9  ]
 T  - truthy indexes                 [1,          3      ]     [1,      2,    3  ]
ṫ   - tail (vectorises)              [[1,0,2,0],  [2,0]  ]     [[1,1,9],[1,9],[9]]
  Ṫ - tail pop                                    [2,0]                       [9]

Si nous ne pouvons pas prendre de listes décimales, un 6 octets est:

DµṫTṪḌ

Que vous pouvez voir ici .

Cela fait la même chose, mais convertit un entier en une liste décimale au préalable et reconvertit en un entier par la suite.

C, 30 29 27 octets

Fier de cela alors que j'abuse de deux exploits de C pour jouer au golf (décrit à la fin du post); Ceci est spécifiquement pour C (GCC)

3) b=10;f(a){a=a%b?:b*f(a/b);} // 27 octets

2) b;f(a){b=a=a%10?:10*f(a/10);} // 29 octets

1) f(i){return i%10?:10*f(i/10);}// 30 octets

Essayez-le en ligne (version 27 octets)

Première tentative (30 octets): abuse du fait que, dans GCC, si aucune valeur n'est déclarée en ternaire, la valeur conditionnelle sera renvoyée. D'où la raison pour laquelle mon opérateur ternaire est vide pour la valeur de retour de vérité.

Deuxième tentative (29 octets): Abuse un bogue de mémoire dans GCC où, pour autant que je sache, si une fonction n'a pas de valeur de retour, lorsque plus de deux variables ont été utilisées de manière significative dans la fonction, la dernière valeur définie du premier argument sera retourné.
   (Édition: mais cette "valeur définie" doit être définie de certaines manières, par exemple définir une variable avec =ou +=fonctionne, mais la définir avec %=ne fonctionne pas; bizarre)

Troisième tentative (27 octets): Étant donné que je dois utiliser de manière significative la deuxième variable (b) pour abuser correctement du bogue de mémoire mentionné ci-dessus, je peux aussi bien l’utiliser comme variable réelle pour "10" à des fins de substitution.
   (Remarque: je devrais pouvoir permuter a=a%bavec a%=bpour enregistrer un autre octet, mais malheureusement, l'exploit de mémoire ci-dessus cesse de "fonctionner", je ne peux donc pas)

Retina , 7 à 6 octets

!`.0*$

Essayez-le en ligne (tous les cas de test)

Les correspondances de sortie d'un chiffre suivi de zéros à la fin de la chaîne d'entrée. Bien que non requis, cela se passe aussi pour 0.

Cubix , 18 32 octets

Je pense que je devrai y revenir un peu plus tard et voir si je peux le compresser un peu. Mais pour le moment le voici.
Il se trouve que je pensais à cela totalement dans le mauvais sens. Maintenant, le processus applique de manière incrémentielle un mod (1,10,100,1000, ...) à l'entier en entrée et affiche le premier qui n'est pas zéro. Un peu plus ennuyeux, mais plus court.

!N%*I1^\.u;u@O\;;r

Essayez-le ici

    ! N
    % *
I 1 ^ \ . u ; u
@ O \ ; ; r . .
    . .
    . .

JavaScript, 21 octets

f=n=>n%10||10*f(n/10)

Cas de test

f=n=>n%10||10*f(n/10)

console.log(f(1   )); //  1
console.log(f(2   )); //  2
console.log(f(10  )); //  10
console.log(f(29  )); //  9
console.log(f(99  )); //  9
console.log(f(1020)); //  20

Javascript 19 18 octets

Merci à ETHproductions pour le golf d'un octet et à Patrick Roberts pour le golf de deux octets

x=>x.match`.0*$`

Retourne un tableau de chaînes qui correspond à l'expression régulière à la fin de la chaîne d'entrée avec n'importe quel caractère suivi du plus grand nombre de zéros possible.

Essayez-le en ligne

Bash + coreutils, 12

grep -o .0*$

Essayez-le en ligne .

Grime , 5 octets

d\0*e

Essayez-le en ligne!

Explication

       Find the longest substring of the input matching this pattern:
d      a digit, then
 \0*   zero or more 0s, then
    e  edge of input (which is handled as an Nx1 rectangle of characters).

Brachylog , 2 octets

a₁

Essayez-le en ligne!

Le suffixe intégré a₁, pour les entiers, est implémenté comme suit :

brachylog_adfix('integer':1, 'integer':0, 'integer':0).
brachylog_adfix('integer':1, 'integer':I, 'integer':P) :-
    H #\= 0,
    H2 #\= 0,
    abs(P) #=< abs(I),
    integer_value('integer':Sign:[H|T], I),
    integer_value('integer':Sign:[H2|T2], P),
    brachylog_adfix('integer':1, [H|T], [H2|T2]).

Brachylog aime pouvoir traiter les nombres entiers comme des listes de chiffres et utilise pour cela le prédicat de l'utilitaire personnalisé integer_value/2. La chose intéressante à propos integer_value/2ici est que, comme il doit être capable de traduire correctement une liste de chiffres avec des zéros non significatifs, il est également possible de traduire un entier en une liste de chiffres avec des zéros non significatifs, donc les prédicats qui ne le souhaitent pas. arrive (la plupart d’entre eux, en particulier ceux qui ne sont pas ressemblants a) interdisent aux têtes de leurs listes de chiffres d’être égaux à 0. Ainsi, tout en a₁générant les suffixes les plus courts en premier pour les listes et les chaînes, il saute tout suffixe d’un entier avec un 0 en tête, Outre l’élimination des doublons, cela signifie également que le premier suffixe généré est le dernier chiffre différent de zéro, avec tous les zéros à la fin.

Flaque de cerveau , 74 octets

{({}<>)<>}(()){{}<>(({}<>)[((((()()()){}){}){}){}]<(())>){((<{}{}>))}{}}{}

Essayez-le en ligne!

Imprime uniquement les derniers non-0 et tous les derniers 0.

Explication:

{({}<>)<>}                    # Move everything to the other stack (reverse the input)
(())                          # Push a 1 to get started
{                             # do...
  {}<>                        #   pop the result of the equals check (or initial 1)
  (                           #   push...
    ({}<>)                    #     the top value from the other stack (also put this on the stack)
    [((((()()()){}){}){}){}]  #     minus the ASCII value of 0
    <(())>                    #     on top of a 1
  )                           #   close the push   
  {                           #   if not zero (ie. if not equal)
    ((<{}{}>))                #     replace the 1 from 3 lines back with a 0
  }{}                         #   end if and pop the extra 0
}                             # while the copied value != "0"
{}                            # pop the result of the equals check

Vim, 19 octets

Deux versions, les deux 19 octets:

:s/\v.*([^0]0*)/\1
:s/.*\([^0]0*\)/\1

Plus un retour de chariot de fuite sur chacun.

Vérifiez tous les cas de test en ligne! (Un octet ajouté pour tester sur plusieurs lignes)

TI-Basic, 18 octets

If fPart(.1Ans
Return
Ans.1
prgmA
10Ans

R, 33 octets

Implémenté comme une fonction non nommée

function(x)rle(x%%10^(0:99))$v[2]

Ceci s'applique à un mod de 10 ^ 0 à 10 ^ 99. rleest utilisé pour réduire les résultats afin que le deuxième élément soit toujours le résultat souhaité.
Essayez-le en ligne!

Zsh , 18 16 octets

<<<${(M)1%[^0]*}

Essayez-le en ligne! Essayez-le en ligne!

Bash , 25 octets

r=${1%[^0]*}
echo ${1#$r}

Essayez-le en ligne!

Les shells ont besoin d'appeler des programmes externes pour utiliser regex, nous devons donc nous débrouiller avec globbing.

L' ${1%[^0]*}extension correspond au suffixe le plus court commençant par un caractère différent de zéro et le supprime.

• Dans Zsh, l'ajout de l' (M)indicateur permet de conserver le suffixe correspondant au lieu de le supprimer.
• Dans Bash, l' ${1% }extension supprime comme préfixe tout ce qui reste.

GNU sed , 17 14 + 1 (drapeau r) = 15 octets

Edit: 2 octets de moins grâce à Riley

s:.*([^0]):\1:

Cela fonctionne en supprimant tout jusqu'au chiffre non nul le plus à droite, qui est ensuite imprimé avec tous les zéros de fin existants. Le script peut gérer plusieurs tests en une fois, chacun sur une ligne distincte.

Essayez-le en ligne! (tous les exemples de tests)

Mathematica, 26 octets

Fonction pure qui prend une liste de chiffres et génère une liste de chiffres:

#/.{___,x_,y:0...}:>{x,y}&

Explication

#                           First argument
 /.                           Replace
   {                              start of list followed by
    ___,                          zero or more elements followed by
        x_,                       an element (referred to later as x) followed by
           y:0...                 a sequence of zero or more 0s (referred to later as y) followed by
                 }                end of list
                  :>            with
                    {x,y}         {x,y}
                         &   End of function.

Cela fonctionne car il trouve la correspondance la plus à gauche pour x, qui doit être l'élément non nul le plus à droite de la liste car il est suivi d'une séquence de zéro de plus 0s, puis de la fin de la liste.

Java 8, 47 octets

c'est une expression lambda assignable à un IntUnaryOperator:

x->{int m=1;for(;x%m<1;m*=10);return x%m*m/10;}

explication: multiplier m par 10 jusqu'à ce que x%mN'est pas égal à 0. return x%m*m/10Nécessite la division, car m est un ordre de grandeur supérieur au résultat souhaité.

Perl 6 , 10 octets

{+m/.0*$/}

Solution de regex triviale. Entrer et sortir un nombre.

MATL , 10 7 octets

3 octets sauvegardés grâce à @B. Mehta!

tfX>Jh)

L'entrée et la sortie sont un tableau de chiffres.

Essayez-le en ligne!

Ou vérifier tous les cas de test .

Explication

t     % Input string implicitly. Duplicate
f     % Push indices of non-zero digits
X>    % Keep maximum, say k
Jh    % Attach 1j to give [k, 1j]. This is interpreted as an index "k:end"
)     % Index into original string. Display implcitly

C #, 30 28 octets

Basé sur cette réponse JavaScript , je suppose donc que tous les crédits lui vont un peu.

Golfé

i=a=>a%10<1?10*i(a/10):a%10;

• -2 octets en supprimant ()environ agrâce à Emigna

J, 27 octets

10&|`(10*(p%&10))@.(0=10&|)

Il est basé sur la formule de xnor, donc créditez-le.

Kotlin, 49 octets

lambda, assignable à (List<Int>) -> List<Int>

{a->a.slice(a.indexOfLast{it in 1..9}..a.size-1)}

• nom de paramètre implicite itdansindexOfLast
• .. pour construire des gammes

Perl 5, 12 octets

11, plus 1 pour -nEau lieu de-e

say/(.0*$)/

05AB1E , 9 octets

RD0Ê1k>£R

Essayez-le en ligne! ou en tant que suite de tests

Explication

R          # reverse input
 D         # duplicate
  0Ê       # check each for inequality with 0
    1k     # get the index of the first 1
      >    # increment
       £   # take that many digits from the input
        R  # reverse

Japt , 6 octets

f".0*$

Essayez-le en ligne!

Stax , 5 octets

æΩ$3╚

Exécuter et déboguer

Procédure:

1. Calculez la "multiplicité" par 10. (C'est le nombre de fois que 10 divise également l'entrée)
2. Ajouter 1.
3. Conservez autant de caractères à droite de (l'entrée sous forme de chaîne).

05AB1E , 4 octets

ĀÅ¡θ

I / O sous forme de liste de chiffres.

Essayez-le en ligne ou vérifiez tous les cas de test (la suite de tests contient une jointure pour une meilleure lisibilité).

Explication:

Ā     # Python-style truthify each digit in the (implicit) input-list (0 if 0; 1 if [1-9])
      #  i.e. [9,0,4,0,3,0,0] → [1,0,1,0,1,0,0]
 Å¡   # Split the (implicit) input-list on truthy values (1s)
      #  i.e. [9,0,4,0,3,0,0] and [1,0,1,0,1,0,0] → [[],[9,0],[4,0],[3,0,0]]
   θ  # And only leave the last inner list
      #  i.e. [[],[9,0],[4,0],[3,0,0]] → [3,0,0]
      # (after which it is output implicitly as result)

Pyke, 13 11 10 octets

`1QY0mN%e>

Essayez-le ici!

  QY       -     digits(input)
    0mN    -    map(^, i != 0)
 1     %   -   indecies(^, i == 1)
        e  -  ^[-1]
`        > - str(input)[^:]

11 octets:

`D\0mN1R%e>

Essayez-le ici!

13 octets:

`D\0mN_1R@_t>

Essayez-le ici!

Haskell 57 octets

f(x:s)a|x=='0'=f s$'0':a|1>0=x:a
t x=f(reverse.show$x)[]

Input    -> Output
t 120    -> "20"
t 30200  -> "200"