Desafio:

Na linguagem de programação de sua escolha, aceite um número inteiro como entrada na base 10 e envie-o na notação negadecimal , também conhecida como base -10

Exemplo de algoritmo:

Este é um algoritmo retirado da Wikipedia para converter a base 10 em qualquer base negativa no VB.NET :

Function toNegativeBase(Number As Integer , base As Integer) As System.Collections.Generic.List(Of Integer)

    Dim digits As New System.Collections.Generic.List(Of Integer)
    while Number <> 0
        Dim remainder As Integer= Number Mod base
        Number = CInt(Number / base)

        if remainder < 0 then
            remainder += system.math.abs(base)
            Number+=1
        end if

        digits.Insert(0, remainder)
    end while

    return digits
end function

Obviamente, você pode usar qualquer algoritmo, desde que cumpra o desafio

Exemplos de entradas / saídas:

Entrada:

12

Resultado:

192

Outro exemplo:

Entrada:

2048

Resultado:

18168

Regra:

Você não deve usar nenhum método interno que resolva esse problema existente na sua linguagem de programação

Este é um código de golfe , então o código mais curto vence!

JavaScript (ES6), 51 45 37 bytes

f=n=>n&&n%10+((k=n<0)+f(k-n/10|0))*10

Casos de teste

f=n=>n&&n%10+((k=n<0)+f(k-n/10|0))*10

console.log("12 -> " + f(12))
console.log("2048 -> " + f(2048))

Japonês , 11 bytes

_ì ìAn)¥U}a

Teste online!

Explicação

_ì ìAn)¥U}a  // Implicit: U = input integer, A = 10
_        }a  // Return the smallest non-negative integer Z that returns a truthy value
             // when run through this function:
 ì           //   Convert Z to a list of its base 10 digits.
   ìAn)      //   Interpret this as a list of base -10 digits and convert to a base 10 integer.
       ¥U    //   Return (the result == U).
             // Implicit: output result of last expression

Lote, 82 bytes

@set/a"d=%1%%10,n=%1/-10-(a=d>>4),d-=a*10
@if %n% neq 0 %0 %n% %d%%2
@echo %d%%2

A divisão do lote é truncada para zero; portanto, se o restante for negativo, preciso adicionar 1 (e também adicionar 10 ao restante) para compensar. Os dígitos são acumulados %2até o resultado se tornar zero.

Geléia , 9 bytes

Dḅ-10=ð1#

Esta é uma inversão de força bruta da conversão negadecimal em número inteiro.

Experimente online!

Como funciona

Dḅ-10=ð1#  Main link. Argument: n

      ð    Combine the links to the left into a chain and start a new, dyadic
           chain with left and right argument n.
       1#  Repeatedly execute the chain with left argument k = n, n + 1, ... and
           right argument n until the first match is found.
D          Convert k to decimal.
 ḅ-10      Convert the result from base -10 to integer.
     =     Compare the result with n.

Pitão - 9 bytes

Lel tem o emoji chorando nele.

fqQijT;_;

Conjunto de Teste .

Python 3, 35 bytes

f=lambda n:n and n%10+f(0-n//10)*10

Porta Python do algoritmo de Arnauld .

Como alternativa, para 102 bytes, uma função genérica usando o algoritmo da postagem original:

def f(n,b,r=0):
 if n:
  r,n=n%b,n//b
  if r<0:r+=abs(b);n+=1
  return f(n,b,r)+str(r)
 else:return ""

Gelatina , 10 bytes

:⁵NµÐĿ%⁵ṚḌ

Experimente online!

fundo

A conversão de uma lista de não-negativos da base b para o número inteiro pode ser obtida dobrando-se à esquerda pela função x, y ↦ bx + y . Para converter e inteiro para base b , devemos simplesmente reverter essa função, ou seja, encontrar uma expressão para bx + y ↦ x, y .

No Python (e, por extensão, Jelly), o resultado do operador módulo é sempre negativo, portanto (bx + y)% | b | = y .

Além disso, a divisão inteira sempre arredonda para baixo, certificando-se de que, se q = n / d e r = n% d , a igualdade n = qd + r detém. Se s é o sinal de b , então (sx) | b | + y = bx + y , então sx = (bx + y) / | b | e, portanto, s ((bx + y) / | b |) = x.

Como funciona

:⁵NµÐĿ%⁵ṚḌ  Main link. Argument: n

   µ        Combine the links to the left into a monadic chain.
    ÐĿ      Iteratively apply the chain until the results are no longer unique.
            Collect all unique results in an array.
:⁵            Divide the previous return value (initially n) by 10.
  N           Negate; multiply the result by -1.
      %⁵    Take all results modulo 10.
        Ṛ   Reverse the results.
         Ḍ  Convert from base 10 to integer.

SimpleTemplate , 147 bytes

Esta é uma linguagem de modelo em que estou trabalhando.
De maneira alguma é para o golfe.
Até falta matemática básica completa, mas permite escrever pequenos trechos de PHP diretamente.
Isso funciona em torno desse problema.

{@setN argv.0}{@whileN}{@setM N}{@php$DATA[N]=($DATA[M]/-10)|0;$DATA[R]=$DATA[M]%-10}{@ifR is lower0}{@incby10 R}{@incN}{@/}{@setD R,D}{@/}{@echoD}

Isso lança um monte de avisos.
O código é "compilado" no PHP.

Sem golfe, com espaço em branco no lixo:

{@set no argv.0}
{@while no}
    {@set temp_no no}
    {@php $DATA["no"] = ($DATA["temp_no"] / -10) | 0}
    {@php $DATA["remainder"] = $DATA["temp_no"] % 10}

    {@if remainder is lower than 0}
        {@inc by 10 remainder}
        {@inc no}
    {@/}
    {@set digits remainder, digits}
{@/}
{@echo digits}

Se necessário, uma explicação passo a passo pode ser adicionada, mas acredito que seja bem direta.

Isenção de responsabilidade :

O último commit, no momento da redação desta resposta, era em 07-01-2017 20:36 UTC + 00: 00.
Isso funciona no commit 140e56ff38f45fa4fd40fd3ec382094e707b1bad de 06-01-2017 23:27 UTC + 00: 00.
Essa é a versão usada para executar esta resposta.

O código PHP está disponível em https://raw.githubusercontent.com/ismael-miguel/SimpleTemplate/140e56ff38f45fa4fd40fd3ec382094e707b1bad/SimpleTemplate.php

Eu recomendo executar isso com a última versão, mas essa funciona bem para esta pergunta.

Como correr?

Crie um arquivo com o código e execute-o assim:

<?php

    include 'path/to/SimpleTemplate.php';

    $template = new SimpleTemplate('<code>');

    $template->render(<number>);

O valor será exibido na tela.

PHP, 71 67 bytes

for(;$n=&$argn;$n=$g-$n/10|0)$d=($r=$n%10)+10*($g=$r<0).$d;echo+$d;

ou 62 bytes para uma porta da resposta de Arnauld :

function n($n){return$n?$n%10+(($k=$n<0)+f($k-$n/10|0))*10:0;}

Mathematica, 49 bytes

d@0="";d@n_:=d[-Floor[n/10]]<>ToString[n~Mod~10];

Define uma função dusando um argumento inteiro e retornando uma sequência. Um algoritmo recursivo - parece o mesmo algoritmo na resposta de Arnauld . Funciona também com números negativos. (Retorna a string vazia no cabeçalho de "0" se a entrada for 0.) Nota para jogadores do Mathematica: o uso ±requer um conjunto extra de parênteses e, portanto, parece não ser mais curto.

C, 68 bytes

main(f,a){f&&scanf("%d",&a);f=a?a%10+((f=a<0)+main(0,f-a/10))*10:0;}

Em vez de imprimir o número resultante, o programa apenas o retorna. Obviamente, essa é a resposta de Arnauld , a única diferença é que, como C não é uma linguagem interpretada, senti que deveria torná-lo um programa completo, em vez de apenas uma função.

Ferrugem, 88 bytes

fn g(mut n:i32)->i32{let mut r=n%10;n/=-10;if r<0{r+=10;n+=1;}if n==0{r}else{r+g(n)*10}}

Esta é apenas uma versão recursiva do algoritmo fornecido na pergunta.