La mayoría de las computadoras almacenan enteros en binario, pero los generan en decimal. Sin embargo, el decimal es solo una representación, resulta que lo encontramos conveniente.

Este desafío es escribir un código para generar un valor entero en shortlex decimal .

¿Que es eso?
http://en.wikipedia.org/wiki/Shortlex_order

Shortlex toma la longitud de la secuencia de dígitos como el significante principal del valor. La secuencia, comenzando desde una cadena vacía que representa cero, es ...

ε,0,1,...,8,9,00,01,...98,99,000,001,...,998,999,0000,...

(Piense en las columnas de Excel, pero usando solo los dígitos decimales).

Escriba un programa o función que acepte un número entero y devuelva una cadena correspondiente a la representación decimal-shortlex de ese número entero como se describió anteriormente.

Valores de prueba:

0 → "" (cadena vacía)
1 → "0"
10 → "9"
11 → "00"
42 → "31"
100 → "89"
800 → "689"
1060 → "949"
10270 → "9159"
100501 → "89390"

JavaScript (ES6) 42 74

n=>(n-~(n+'').replace(/./g,8)+'').slice(1)

Prueba en la consola FireFox

;[0,1,10,11,42,100,800,1060,10270,100501]
.forEach(x => console.log(x +" -> '" + S(x) + "'"))

Salida

0 -> ''
1 -> '0'
10 -> '9'
11 -> '00'
42 -> '31'
100 -> '89'
800 -> '689'
1060 -> '949'
10270 -> '9159'
100501 -> '89390'

¿Cómo pensé en esto?

Dado un número fijo de dígitos, la secuencia de salida es simplemente ascendente, por lo que hay un delta fijo entre entrada y salida. Echar un vistazo:

  1..10 -> 0..9 (delta -1)
 11..110 -> 00..99 (delta -11)
111..1110 -> 000..999 (delta -111) mmm there's a pattern here...

Pero los 0 iniciales son difíciles de administrar, por lo que tengo un truco estándar, agrego un primer dígito y modulo de trabajo (es decir, corta el primer dígito en la salida). Entonces -1-> +9, -11 -> +89, -111 -> +889 y así sucesivamente.
Último paso: no me importa cuál sea el primer dígito, por lo que no es necesario verificar si el número de entrada es <o> que 111 ... (sinceramente, encontré esto por prueba y error)

Prueba

var F=
n=>(n-~(n+'').replace(/./g,8)+'').slice(1)

function update()
{
  var i=+I.value
  O.textContent = F(i)
}


update()

<input id=I value=99 type=number oninput='update()'><pre id=O></pre>

Marbelous 177 173 170

@0@6000000@5
}0&0&0&0&0
>0@6&3
\\--\/&2
@0/\@4\/&1!!
@4@1..@2@5@3
IIIIIIIIIIII
FF&1FF&2FF&3
@1OO@2OO@3OO
:I
}1..}10001F7
=9&1++..&1&0
&0}0&1&0{1{1
{>\/{0//
:O
}0
+Z
+C
{0

Funciona solo para valores inferiores a 256 ya que Marbelous es un lenguaje de 8 bits.

Cómo funciona

Marbelous es un lenguaje 2D con valores representados por canicas de 8 bits que caen una celda en cada tic a menos que algún dispositivo evite que se caigan. Este programa maravilloso consta de 3 tableros; Comencemos con el más fácil:

:O
}0
+Z
+C
{0

:Oes el nombre de la placa (para ser precisos, O es el nombre y: le dice al interpretado que esta línea es un nombre. Al dar un nombre a las placas, otras placas pueden invocarlas como }0un dispositivo de entrada, esto puede verse como un argumento de esta función. Esta celda será reemplazada por una canica de entrada (valor) cuando se llama a la función. +ZAgrega 35 a cualquier canica que la pase y la deje caer. +CHace lo mismo pero solo agrega 12. {0Es una celda de salida , cuando una canica llega a esta celda, la función saldrá y devolverá el valor en este dispositivo de salida.

Entonces, todos juntos, este tablero toma un valor y luego le agrega 47. Para nosotros, esto significa que convierte cualquier número de un solo dígito en el código ASCII del dígito -1 (esto, por supuesto, también funcionará para 10).

:I
}1 .. }1 00 01 F7
=9 &1 ++ .. &1 &0
&0 }0 &1 &0 {1 {1
{> \/ {0 //

Este tablero se ve un poco más complicado. Debería poder identificarse :Icomo el nombre de la placa y haber detectado algunos dispositivos de entrada y salida. Notarás que tenemos dos dispositivos de entrada diferentes, }0y }1. Esto significa que esta función toma 2 entradas. También notará que hay dos instancias del }1dispositivo. Al llamar a la función, ambas celdas contendrán el mismo valor. El }0dispositivo de entrada está directamente encima de un \/dispositivo, esto actúa como un basurero y elimina cualquier canica que caiga sobre él inmediatamente.

Echemos un vistazo a lo que le sucede a una de las canicas colocadas en la placa por los }1dispositivos de entrada:

}1
=9 &1
&0
{>

Caerá en el primer tic y golpeará el =9dispositivo. Esto compara el valor de la canica con 9 y permite que la canica se caiga si el enunciado se =9evalúa. El mármol se empuja hacia la derecha si no. &0y &1son sincronizadores. Se aferran a las canicas que caen sobre ellas hasta que todos los demás &nsincronizadores se llenen también. Como puede esperar, esto condicionalmente desencadenará un comportamiento diferente en alguna otra parte del tablero.

}1 00 01 F7
++ .. &1 &0
&1 &0 {1 {1
{0 //

Si te digo que ++es un incrementador, ya deberías poder decir con qué se llenarán los diferentes sincronizadores. La izquierda &1contendrá el valor de entrada }1+ 1, la &0siguiente contendrá 0 ( 00es un lenguaje literal, representado en hexadecimal). El segundo &1contendrá el valor 1 y el derecho &0se rellena con un F7, que resta 9 de un valor ya que la adición en Marbelous es el módulo 256.

// es un dispositivo deflector que empuja cualquier canica hacia la izquierda en lugar de dejarla caer.

Poner todo esto junto te da esto: si la canica adentro }1es 9, los &0sincronizadores se llenan. Esto hará que el valor 0 caiga en la {0salida y F7(o -9) en la {1salida. Si }1no es 9, {0se rellenará con }1+ 1 y {0contendrá 1. También hay un {>dispositivo, esta es una salida especial que genera una canica junto a una placa en lugar de debajo de ella. Esto se llenará }1si es igual a 9.

@0 @6 00 00 00 @5
}0 &0 &0 &0 &0
>0 @6 &3
\\ -- \/ &2
@0 /\ @4 \/ &1 !!
@4 @1 .. @2 @5 @3
II II II II II II
FF &1 FF &2 FF &3
@1 OO @2 OO @3 OO

Bien, ahora para el grande. Esta placa no tiene un nombre explícito, ya que es la placa principal del archivo. Su nombre implícito es Mb. Deberías poder reconocer algunas células. Hay un dispositivo de entrada, algunos literales de lenguaje ( 00y FF). Hay algunos sincronizadores y hay un deflector. pasemos por esto pieza por pieza.

@0 @6
}0 &0
>0 @6
\\ --
@0 /\ @4

Entonces, el valor de entrada (la entrada de la línea de comando ya que esta es la placa principal) comienza en la segunda celda desde la parte superior donde }0se encuentra. Se caerá y alcanzará el >0dispositivo, que es otro dispositivo de comparación. cualquier canica mayor que 0 cae, cualquier otra canica se empuja hacia la derecha. (dado que las variables Marbelous no están firmadas, solo exactamente 0 será empujado hacia la derecha). Este mármol de valor cero golpeará el @6dispositivo. Este es un portal y transporta la canica a otro portal correspondiente, en este caso justo encima de él. La canica 0 alcanzará el &0sincronizador y activará algunas cosas en otro lugar.

Si la canica no es 0, se cae, se desvía hacia la derecha por \\golpes --que la disminuyen en uno y luego cae sobre /\un clonador. Este dispositivo toma una canica y genera una copia a la derecha y otra a la izquierda. La izquierda se llevará hacia arriba a la otra, @0donde la canica volverá a pasar por la misma secuencia. La izquierda será llevada a otra parte. Esto nos da un bucle, que disminuye la entrada de la línea de comando una vez por bucle y desencadena un comportamiento en cada bucle hasta que alcanza 0. Luego, desencadena algún otro comportamiento.

Echemos un vistazo a lo que sucede con la canica presionada en @4cada bucle.

@4 @1 .. @2 @5 @3
II II II II II II
FF &1 FF &2 FF &3
@1 OO @2 OO @3 OO

Aquí hay 3 literales de lenguaje ( FF), que inmediatamente caerán en portales. Estos portales los llevarán a tres de los IIdispositivos. IIse refiere al tablero :Ique definimos más abajo en el archivo. Como :Itiene 2 dispositivos de entrada distintos, su representación en otra placa debe tener 2 celdas de ancho. Como tenemos 6 celdas que contienen II, podemos decir que tenemos 3 instancias de esta función en el tablero.

Las FFcanicas (o 256 o -1 si lo desea) se sentarán en las celdas de entrada de la :Ifunción esperando hasta que haya suficientes canicas de entrada para iniciar la función (una más). Ahí es donde @4entra el portal. Una copia de la entrada de línea de comando decrementada cae por allí en cada bucle. Esto activará el :Itablero más a la izquierda . Inicialmente con los valores 256 (o -1) y cualquiera que sea la entrada de la línea de comando fue -1. El mármol izquierdo se colocará en los }0dispositivos del :Itablero y el derecho en el }1. Si recuerda lo que hizo este tablero, podrá saber qué resultado tiene. Producirá una versión incrementada de la entrada derecha en la salida izquierda (y convierte un 9 en 0, no en 10) y generará 1 o -9 a la derecha.

El valor incrementado será llevado de vuelta a la celda de entrada derecha por un portal, y el valor de la derecha cae en un sincronizador. Si un sincronizador ya está sosteniendo una canica, las dos canicas chocarán. Las canicas en colisión se suman en el módulo 256. Por lo tanto, los valores en los sincronizadores harán lo siguiente: comienzan vacíos, luego pasan a 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 y luego a 1 de nuevo (ya que se agrega 247 módulo 256).

También es posible que recuerde que una canica sale a la derecha cuando el valor de entrada vuelve a 0. Ya que las :Iplacas están una al lado de la otra, esto activará la placa a la derecha una vez. Esto llenará los tres sincronizadores con valores que son uno más alto de lo que deberían ser para ser una representación de shortlex de la entrada de la línea de comando, para cuando esto haya pasado a 0.

También puede recordar que la :Ofunción convierte un valor en el valor ascii del dígito que representa el valor -1. La salida de estas OOceldas se caerá del tablero, que imprime sus caracteres ascii correspondientes en STDOUT.

00 00 00 @5
&0 &0 &0
&3
\/ &2
   \/ &1 !!
      @5

Entonces, ¿qué sucede cuando la canica de entrada de línea de comando llega a 0 y llena los &0sincronizadores? bueno, algunas canicas de valor 0 caen y activan los tres sincronizadores que contienen los dígitos (+ 1) del número shortlex en la parte inferior del tablero. &3se activa primero, ya que contiene el dígito más significativo, luego viene &2seguido de &1. Esta canica se teletransporta al otro @5dispositivo antes de eventualmente golpear la !!celda, que termina el tablero.

CJam, 14 11 bytes

l40f-Ab)s1>

Pruébalo en línea.

Cómo funciona

Este enfoque se basa en gran medida en la respuesta de edc65 (con su permiso explícito ):

" Read a line L from STDIN. ";

l

" edc65's answer now forms an integer N by replacing each digit in L by an 8 and computes
  L - ~N = L + N + 1. Instead of adding L and N, we subtract 40 from each char code of L.
  Since the char code of the digit `D` is `D + 48`, this basically adds 8 to each digit.  ";

40f-

" Turn the resulting array into an integer by considering its elements a base 10 number.
  This is implemented as A ↦ A[-1] + 10 * A[-2] + 100 * A[-3] + ⋅⋅⋅, so it won't choke
  on digits greater than the base.                                                        ";

Ab

" Increment the integer on the stack to complete the calculation of L + N + 1.            ";

)

" Push the integers string representation and discard its first character.                ";

s1>

Ejecución de ejemplo

$ for i in 0 1 10 11 42 100 800 1060 10270 100501
> do echo $i: $(cjam <(echo 'l40f-Ab)s1>') <<< $i)
> done
0:
1: 0
10: 9
11: 00
42: 31
100: 89
800: 689
1060: 949
10270: 9159
100501: 89390

Pitón 2 (38) (43)

f=lambda n:n*'_'and f(~-n/10)+`~-n%10`

Sin sustitución de caracteres, solo aritmética.

Sin golf:

def f(n):
    if n==0: return ''
    else: return f((n-1)//10) + str((n-1)%10)

No tengo una buena razón por la cual la recursión funciona, solo ajusto este patrón a la lista de valores. Si cambiara cada uno n-1a n, obtendría la representación de dígitos regular.

Para jugar al golf, utilizo ~-npara calcular n-1con mayor prioridad que /10o %10, ahorrando en parens. El n*'_'es solo para producir la cadena vacía cuando n=0y cualquier otra cadena de lo contrario. El '_'puede ser cualquier cadena para este propósito.

Ruby, 70 68 66 64 57 bytes

f=->n{i=-1;n-=10**i while n>=10**i+=1;i<1?'':"%0#{i}d"%n}

Define una función para ser llamada como f[42]. Aquí está el desglose aproximado del algoritmo:

• Tratar por 0separado.
• Resta potencias de 10 hasta que la próxima potencia de 10 ya no entre en el número.
• Convierte el número en una cadena rellenada con ceros a la izquierda.

¡Los créditos por la idea de usar una cadena de formato van a Falko!

Alternativamente, usando el enfoque de edc65:

f=->n{"#{n-~n.to_s.tr('^.',?8).to_i}"[1..-1]}

Eso es 45 bytes y solo lo incluyo, porque no lo estoy golpeando con él. ;)

Haskell, 67 bytes

n('9':x)='0':n x
n(c:x)=succ c:x
n""="0"
f x=reverse$iterate n""!!x

Esta solución básicamente agrega 1 el número dado de veces, en notación shortlex.

uso:

>f 9
"8"
>f 100
"89"

CJam, 16 bytes

li_)9*,{`1>}%_&=

Pruébalo en línea. Requiere al menos O (n) tiempo y memoria, así que deje 100501 para el intérprete fuera de línea ...

Cómo funciona

La idea básica detrás de este enfoque es calcular al menos N decimales shortlex en su orden natural y descartar todos menos el Nth. No muy eficiente, pero corto.

li                " Read an integer N from STDIN.                                   ";
  _)9*            " Push M := (N + 1) * 9.                                          ";
      ,           " Push A := [ 0 1 ... M - 1 ].                                    ";
       {   }%     " For each I ∊ A:                                                 ";
       {`1>}%     " Push its string representation and discard the first character. ";
             _&   " Remove duplicates from the resulting array.                     ";
               =  " Retrieve the Nth element.                                       ";

Ejecución de ejemplo

$ for i in 0 1 10 11 42 100 800 1060 10270 100501
> do echo $i: $(cjam <(echo 'li_)9*,{`1>}%_&=') <<< $i)
> done
0:
1: 0
10: 9
11: 00
42: 31
100: 89
800: 689
1060: 949
10270: 9159
100501: 89390

Bash + coreutils, 27 bytes

El puerto de la respuesta inteligente de @ edc65 , con las mejoras de @ Dennis :

cut -b2-<<<$[$1-~${1//?/8}]

Salida:

$ for n in 0 1 10 11 42 100 110 111 800 1060 1110 1111 10270 100501; do echo "./shortlex.sh $n = \"$(./shortlex.sh $n)\""; done
./shortlex.sh 0 = ""
./shortlex.sh 1 = "0"
./shortlex.sh 10 = "9"
./shortlex.sh 11 = "00"
./shortlex.sh 42 = "31"
./shortlex.sh 100 = "89"
./shortlex.sh 110 = "99"
./shortlex.sh 111 = "000"
./shortlex.sh 800 = "689"
./shortlex.sh 1060 = "949"
./shortlex.sh 1110 = "999"
./shortlex.sh 1111 = "0000"
./shortlex.sh 10270 = "9159"
./shortlex.sh 100501 = "89390"
$ 

Respuesta anterior:

Bash + coreutils, 71 54 bytes

Aquí hay una forma ligeramente diferente de hacerlo:

jot -w%x $1$1|tr 0-9a a0-9|grep -P ^\\d+$|sed $1!d 2>-

• jot salidas que aumentan los enteros hexadecimales
• tr convierte esto a (0,1, ..., 8,9, b, ... f, 0a, 00,01, ..., 99,9b, ..., ff, 0aa, ..., 000 , ...)
• grep simplemente filtra todas las líneas que contienen dígitos para dar (0,1, ..., 8,9,00, ..., 99,000 ....)
• sed elimina todos menos la enésima línea
• STDERR se redirige a un archivo desechable '-' para que simplemente obtengamos la cadena vacía cuando se pasa 0 ( sedcuenta los números de línea que comienzan en 1, por lo que los errores si se pasa 0)
• Debido a que estamos filtrando números con grep, necesitamos generar más enteros de base 11 con seq/ dcque el número de entrada. Repetir los dígitos de n es más que suficiente.

Tenga en cuenta que una vez que se imprime el número de shortlex, seqcontinúa generando números hasta $1$1, lo que disminuye especialmente para números de entrada más grandes: O (n²), creo. Podemos acelerar al seqsalir inmediatamente después de imprimir a un costo de 7 bytes:

jot -w%x $1$1|tr 0-9a a0-9|grep -P ^\\d+$|sed -n $1{p\;q} 2>-

No hay requisitos de velocidad en la pregunta, así que voy con la versión más corta para mi respuesta principal.

Pitón 2 - 84, 70 66

n=input()
i=0
while n>=10**i:n-=10**i;i+=1
print"%%0%dd"%i%n*(i>0)

Enfoque alternativo (misma longitud):

n=input()
k=len(`9*(n+1)/10`)
print"%%0%dd"%k%(n-int('1'*k))*(n>0)

Python 3, 107 caracteres

Esto no terminó ganando, pero pensé que era inteligente:

def G():yield'';yield from(r+c for r in G()for c in'0123456789')
S=lambda n:list(zip(range(n+1),G()))[n][1]

Defino un generador para toda la secuencia en 64 caracteres. Desafortunadamente, tengo que pasar por algunas contorsiones para obtener el enésimo elemento del generador ... si tan solo pudiera hacerlo S=lambda n:G()[n].

Pyth , 12

Otro puerto de la respuesta de @ edc65, quién es el claro ganador (IMO):

t`+hQv*l`Q\8

Paquete de prueba (Gracias a @DigitalTrauama):

$ for n in 0 1 10 11 42 100 110 111 800 1060 1110 1111 10270 100501; do echo "shortlex.pyth $n = \"$(pyth programs/shortlex.pyth <<< $n)\""; done
shortlex.pyth 0 = ""
shortlex.pyth 1 = "0"
shortlex.pyth 10 = "9"
shortlex.pyth 11 = "00"
shortlex.pyth 42 = "31"
shortlex.pyth 100 = "89"
shortlex.pyth 110 = "99"
shortlex.pyth 111 = "000"
shortlex.pyth 800 = "689"
shortlex.pyth 1060 = "949"
shortlex.pyth 1110 = "999"
shortlex.pyth 1111 = "0000"
shortlex.pyth 10270 = "9159"
shortlex.pyth 100501 = "89390"

Explicación:

Q = eval(input())             Implicit.
t`                            All but the first digit of
  +hQ                         Q+1 + 
   v                          eval(
    *l`Q                      len(repr(Q)) * 
     \8                       "8"

Java 8, 60 bytes

n->(n-~new Long((n+"").replaceAll(".","8"))+"").substring(1)

La sorprendente respuesta JavaScript (ES6) del puerto de @ edc65 , ya que dudo que se pueda hacer más corto de manera aritmética en Java.

Pruébalo aquí.

Haskell , 57 bytes

((g=<<[0..])!!)
g 0=[""]
g n=[c:s|c<-['0'..'9'],s<-g$n-1]

Pruébalo en línea!

Construye una lista infinita de números de shortlex e índices para la respuesta. g nconstruye la enésima "generación" de números anteponiendo el siguiente dígito frente a cada uno de los números de la generación anterior.

05AB1E , 7 bytes

Utiliza el reemplazo de edc65 por 8 trucos

8sg×+>¦

Pruébalo en línea!

Explicación

8          # push 8
 sg×       # repeat it len(input) times
    +      # add to input
     >     # increment
      ¦    # discard the first digit

Excel, 37 bytes

Usando el enfoque de @ edc65:

=REPLACE(REPT(8,LEN(A1))+A1+1,1,1,"")

Jalea , 5 bytes

ḃ⁵ịØD

Pruébalo en línea!

Soy muy nuevo en Jelly, así que si puedes mejorar esto, ¡por favor comenta!

Explicación:

ḃ⁵ịØD   Main link.
ḃ       Convert to bijective base ...
 ⁵      10.
  ị     Each number (1 - 10) is converted to the character at its index in the string...
   ØD   “0123456789” (digits)

(Según el comentario de res anterior, el problema es equivalente a convertir el número a la base biyectiva 10)