Quando eu era criança, e queria contar as notas de dólar em minhas economias, eu contava em voz alta:

um dois três quatro cinco seis sete oito nove dez;
onze, doze, treze, quatorze, quinze, dezesseis, dezessete, dezoito, dezenove, vinte;
vinte e um, vinte e dois, vinte e três, vinte e quatro, vinte e cinco ...

Por fim, cansei de pronunciar cada um desses números com várias sílabas. Sendo matemático, criei um método muito mais eficiente de contar:

um dois três quatro cinco seis sete oito nove dez;
um, dois, três, quatro, cinco, seis, sete, oito, nove, vinte;
um, dois, três, quatro, cinco, seis, sete, oito, nove, trinta ...

Como você pode ver, eu pronunciaria apenas os dígitos que foram alterados em relação ao número anterior. Isso tem a vantagem adicional de ser consideravelmente mais repetitivo do que os nomes em inglês para números e, portanto, requer menos inteligência para ser computado.

Desafio

Escreva um programa / função que receba um número inteiro positivo e produza / retorne como eu contaria: ou seja, o dígito diferente de zero e o zero à direita.

Exemplos

   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

Uma lista completa de casos de teste não deve ser necessária. Este é o A274206 no OEIS.

Regras

• Teoricamente, sua entrada deve funcionar para todos os números inteiros positivos, ignorando problemas de precisão e memória.
• A entrada e a saída devem estar em decimal.
• Você pode optar por receber entrada e / ou saída como um número, uma sequência ou uma matriz de dígitos.
• A entrada é garantida como um número inteiro positivo. Sua entrada pode fazer qualquer coisa para entrada inválida.

Isso é código-golfe , então o código mais curto em bytes vence.

Python 2 , 28 bytes

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

Experimente online!

Uma fórmula recursiva funciona muito bem. Se o último dígito for diferente de zero, faça a saída. Caso contrário, remova o zero final, calcule a saída para isso e multiplique por 10.

Gelatina , 6 3 bytes

-3 bytes, tendo E / S como uma lista decimal de dígitos .

ṫTṪ

Conjunto de testes em Experimente online!

Quão?

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

Se não pudéssemos obter listas decimais, um byter de 6 é:

DµṫTṪḌ

Que você pode ver aqui .

Isso faz a mesma coisa, mas converte um número inteiro em uma lista decimal anteriormente e depois converte novamente em um número inteiro.

C, 30 29 27 bytes

Orgulhoso disso, porque eu abusei de dois exploits C para melhorar isso (descrito no final do post); Isto é especificamente para C (GCC)

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

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

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

Experimente online (versão de 27 bytes)

Primeira tentativa (30 bytes): Abusa do fato de que, no GCC, se nenhum valor for declarado em nível ternário, o valor condicional será retornado. Por isso, meu operador ternário está em branco para o valor de retorno da verdade.

Segunda tentativa (29 bytes): Abusa do bug de memória no GCC, onde, até onde eu entendi, se uma função não tem valor de retorno, quando mais de duas variáveis ​​foram utilizadas significativamente na função, o último valor definido da primeira variável de argumento será retornado.
   (Editar: mas esse "valor definido" deve ser definido de determinadas maneiras, por exemplo, definir uma variável com =ou +=funciona, mas configurá-la com %=não funciona; estranho)

Terceira tentativa (27 bytes): Como devo utilizar de maneira significativa a segunda variável (b) para abusar adequadamente do erro de memória mencionado acima, também posso usá-lo como uma variável real para "10" para substituição.
   (Nota: Eu deveria ser capaz de trocar a=a%bcom a%=bpara salvar outro byte mas infelizmente isso faz com que o bug de memória explorar acima para stop "de trabalho", então eu não posso)

Retina , 7 6 bytes

!`.0*$

Experimente online (todos os casos de teste)

Correspondências de saída de um dígito seguidas por zeros no final da sequência de entrada. Embora não seja obrigatório, isso também funciona 0.

Cubix , 18 32 bytes

Acho que vou ter que gastar algum tempo nisso mais tarde e ver se consigo comprimir um pouco. Mas, por enquanto, aqui está.
Acontece que eu estava pensando sobre isso totalmente da maneira errada. Agora, o processo aplica incrementalmente um mod (1,10,100,1000, ...) ao número inteiro de entrada e imprime o primeiro que não é zero. Um pouco mais chato, mas mais curto.

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

Experimente aqui

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

JavaScript, 21 bytes

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

Casos de teste

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 bytes

Graças à ETHproductions por jogar fora um byte e Patrick Roberts por jogar fora dois bytes

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

Retorna uma matriz de cadeias que corresponde ao regex de estar no final da cadeia de entrada com qualquer caractere seguido pelo maior número possível de zeros.

Experimente Online

Bash + coreutils, 12

grep -o .0*$

Experimente online .

Grime , 5 bytes

d\0*e

Experimente online!

Explicação

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

Braquilog , 2 bytes

a₁

Experimente online!

O sufixo interno a₁, para números inteiros, é implementado como:

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]).

O Brachylog gosta de poder tratar números inteiros como listas de dígitos e, para isso, usa o predicado de utilitário personalizado integer_value/2. O interessante integer_value/2aqui é que, como ele deve ser capaz de traduzir corretamente uma lista de dígitos com zeros à esquerda, ele também pode traduzir um número inteiro para uma lista de dígitos com zeros à frente, portanto predicados que não querem que isso acontecem (a maioria deles, especialmente os que não são do tipo eterno a) proíbem que as cabeças de suas listas de dígitos sejam 0. Portanto, embora a₁gere os sufixos mais curtos primeiro para listas e seqüências de caracteres, ignora qualquer sufixo de um número inteiro com um 0 inicial, que em Além de remover duplicatas, também significa que o primeiro sufixo gerado é o dígito diferente de zero à direita com todos os zeros à direita.

Flacidez Cerebral , 74 bytes

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

Experimente online!

Imprime apenas o último não-0 e todos os 0s à direita.

Explicação:

{({}<>)<>}                    # 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 bytes

Duas versões, ambas com 19 bytes:

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

Além de um retorno de carro à direita em cada um.

Verifique todos os casos de teste online! (Um byte adicionado para testar em várias linhas)

TI-Basic, 18 bytes

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

R, 33 bytes

Implementado como uma função sem nome

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

Isso aplica um mod de 10 ^ 0 a 10 ^ 99. rleé usado para reduzir os resultados, para que o segundo item seja sempre o resultado que queremos.
Experimente online!

Zsh , 18 16 bytes

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

Experimente online! Experimente online!

Bash , 25 bytes

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

Experimente online!

Os shells precisam chamar programas externos para usar o regex, então temos que nos contentar com globbing.

A ${1%[^0]*}expansão corresponde ao sufixo mais curto, começando com um caractere diferente de zero, e o remove.

• No Zsh, adicionar o (M)sinalizador faz com que o sufixo correspondente seja mantido em vez de removido.
• No Bash, a ${1% }expansão remove como prefixo o que resta.

GNU sed , 17 14 + 1 (sinalizador r) = 15 bytes

Edit: 2 bytes a menos, graças a Riley

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

Ele funciona excluindo tudo até o dígito diferente de zero, à direita, que é impresso juntamente com os zeros à direita existentes. O script pode manipular vários testes em uma execução, cada um em uma linha separada.

Experimente online! (todos os exemplos de teste)

Mathematica, 26 bytes

Função pura que pega uma lista de dígitos e gera uma lista de dígitos:

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

Explicação

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

Isso funciona, pois encontra a correspondência mais à esquerda para x, que deve ser o elemento diferente de zero à direita da lista, pois é seguida por uma sequência de zero ou mais 0se o final da lista.

Java 8, 47 bytes

esta é uma expressão lambda atribuível a IntUnaryOperator:

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

explicação: multiplique m por 10 até que x%mnão seja 0. return x%m*m/10requer a divisão porque m é uma ordem de magnitude maior que o resultado desejado.

Perl 6 , 10 bytes

{+m/.0*$/}

Solução regex trivial. Insere e gera um número.

MATL , 10 7 bytes

3 bytes salvos graças a @B. Mehta!

tfX>Jh)

Entrada e saída são uma matriz de dígitos.

Experimente online!

Ou verifique todos os casos de teste .

Explicação

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 bytes

Com base nesta resposta JavaScript , suponho que todos os créditos sejam para ele.

Golfe

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

• -2 bytes removendo ()ao redor agraças a Emigna

J, 27 bytes

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

É baseado na fórmula do xnor, então credita a ele.

Kotlin, 49 bytes

lambda, atribuível a (List<Int>) -> List<Int>

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

• nome implícito do parâmetro itemindexOfLast
• .. para construção de faixas

Perl 5, 12 bytes

11, mais 1 para em -nEvez de-e

say/(.0*$)/

05AB1E , 9 bytes

RD0Ê1k>£R

Experimente online! ou como um conjunto de testes

Explicação

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

Japonês , 6 bytes

f".0*$

Experimente online!

Stax , 5 bytes

æΩ$3╚

Execute e depure

Procedimento:

1. Calcule "multiplicidade" por 10. (Esse é o número de vezes que 10 divide a entrada igualmente)
2. Adicione 1.
3. Mantenha tantos caracteres à direita de (a entrada como uma sequência).

05AB1E , 4 bytes

ĀÅ¡θ

E / S como uma lista de dígitos.

Experimente online ou verifique todos os casos de teste (o conjunto de testes contém uma junção para melhor legibilidade).

Explicação:

Ā     # 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 bytes

`1QY0mN%e>

Experimente aqui!

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

11 bytes:

`D\0mN1R%e>

Experimente aqui!

13 bytes:

`D\0mN_1R@_t>

Experimente aqui!

Haskell 57 Bytes

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"