La maggior parte dei computer memorizza numeri interi in binario, ma li emette in formato decimale. Tuttavia, il decimale è solo una rappresentazione, ci è capitato di trovarlo conveniente.

Questa sfida è scrivere del codice per produrre un valore intero in decimale shortlex .

Cos'è quello?
http://en.wikipedia.org/wiki/Shortlex_order

Shortlex prende la lunghezza della sequenza di cifre come significante principale del valore. La sequenza, a partire da una stringa vuota che rappresenta zero, è ...

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

(Pensa alle colonne di Excel, ma usando solo le cifre decimali.)

Scrivi un programma o una funzione che accetta un numero intero e restituisce una stringa corrispondente alla rappresentazione decimale shortlex di quel numero intero come descritto sopra.

Valori di prova:

0 → "" (stringa vuota)
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)

Test nella console FireFox

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

Produzione

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

Come ci ho pensato?

Dato un numero fisso di cifre, la sequenza di output è semplicemente crescente, quindi esiste un delta fisso tra input e output. Dare un'occhiata:

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

Ma gli 0 iniziali sono difficili da gestire, quindi ho un trucco standard, aggiungo una prima cifra e lavoro modulo (ovvero, taglio la prima cifra nell'output). Quindi -1-> +9, -11 -> +89, -111 -> +889 e così via.
Ultimo passo: non mi interessa quale sia la prima cifra, quindi non è necessario verificare se il numero iinput è <o> di 111 ... (sinceramente l'ho trovato per tentativi ed errori)

Test

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

Funziona solo per valori inferiori a 256 poiché Marbelous è un linguaggio a 8 bit.

Come funziona

Marbelous è un linguaggio 2D con valori rappresentati da biglie a 8 bit che cadono su una cella per ogni segno di spunta a meno che un dispositivo non impedisca loro di cadere. Questo programma Marbelous è composto da 3 schede; iniziamo con il più semplice:

:O
}0
+Z
+C
{0

:Oè il nome della scheda (per essere precisi, O è il nome e: dice all'interpretato che questa linea è un nome. Dando un nome alle schede, altre schede possono chiamarle }0è un dispositivo di input, questo può essere visto come un argomento di questa funzione. Questa cella verrà sostituita da un input marmo (valore) quando viene chiamata la funzione. +Zaggiunge 35 a qualsiasi marmo che la attraversa e la lascia cadere. +Cfa lo stesso ma aggiunge solo 12.{0 è una cella di output , quando un marmo raggiunge questa cella, la funzione uscirà e restituirà il valore in questo dispositivo di output.

Quindi tutti insieme, questa scheda prende un valore e quindi ne aggiunge 47. Per noi questo significa che trasforma qualsiasi numero di una singola cifra nel codice ASCII della cifra -1 (questo ovviamente funzionerà anche per 10).

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

Questa scheda sembra un po 'più complicata. Dovresti essere in grado di identificare :Iil nome della scheda e aver individuato alcuni dispositivi di input e output. Noterai che abbiamo due diversi dispositivi di input }0e }1. Ciò significa che questa funzione accetta 2 ingressi. Noterai anche che ci sono due istanze del }1dispositivo. Quando si chiama la funzione, entrambe queste celle conterranno lo stesso valore. Il }0dispositivo di input è direttamente sopra a\/ dispositivo, questo funge da cestino e rimuove immediatamente qualsiasi marmo che vi cade sopra.

Diamo un'occhiata a cosa succede a uno dei marmi messi nella scheda dai }1dispositivi di input:

}1
=9 &1
&0
{>

Cadrà al primo segno di spunta e colpirà il =9dispositivo. Questo confronta il valore del marmo con 9 e lascia cadere il marmo se l'istruzione =9valuta attraverso. Altrimenti il ​​marmo viene spinto a destra. &0e &1sono sincronizzatori. Si aggrappano ai marmi che cadono su di essi fino a quando tutti gli altri &nsincronizzatori non vengono riempiti. Come ci si può aspettare, questo attiverà in modo condizionale comportamenti diversi su qualche altra parte del tabellone.

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

Se ti dico che ++è un incrementatore, dovresti già essere in grado di dire con cosa verranno riempiti i diversi sincronizzatori. La sinistra &1conterrà il valore di input }1+ 1, la &0prossima conterrà 0 ( 00è una lingua letterale, rappresentata in esadecimale). Il secondo &1conterrà il valore 1 e il diritto &0verrà riempito con un F7, che sottrae 9 da un valore poiché l'aggiunta in Marbelous è modulo 256.

// è un dispositivo deflettore, che spinge qualsiasi marmo a sinistra invece di farlo cadere.

Mettere tutto insieme ti dà questo: se il marmo in }1è 9, i &0sincronizzatori si riempiono. Ciò farà cadere il valore 0 {0nell'output e F7(o -9) {1nell'output. Se }1non è 9, {0sarà riempito con }1+ 1 e {0conterrà 1. C'è anche un {>dispositivo, questo è un output speciale che emette un marmo vicino a una tavola al posto di sotto di esso. Questo verrà riempito }1se è uguale 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

Bene, ora per quello grande. Questa scheda non ha un nome esplicito, poiché è la scheda principale del file. Il suo nome implicito è Mb. Dovresti essere in grado di riconoscere alcune celle. C'è un dispositivo di input, alcuni letterali di lingua ( 00e FF). Ci sono alcuni sincronizzatori e c'è un deflettore. lasciamo passare questo pezzo per pezzo.

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

Quindi il valore di input (l'input della riga di comando poiché questa è la scheda principale) inizia nella seconda cella dall'alto in cui }0si trova. Cadrà e raggiungerà il >0dispositivo, che è un altro dispositivo di confronto. qualsiasi marmo più grande di 0 cade, qualsiasi altro marmo viene spinto a destra. (poiché le variabili Marbelous non sono firmate, solo esattamente 0 verrà spostato a destra). Questo marmo a valore zero colpirà quindi il @6dispositivo. Questo è un portale e trasporta il marmo in un altro portale corrispondente, in questo caso proprio sopra di esso. Il marmo 0 raggiungerà quindi il &0sincronizzatore e innescherà alcune cose altrove.

Se il marmo non è 0, cade, viene deviato a destra da \\colpi --che lo diminuiscono di uno e poi cade /\, un clonatore. Questo dispositivo prende un marmo e ne emette una copia a destra e una a sinistra. Quello di sinistra verrà portato verso l'alto all'altro@0 dove il marmo passerà di nuovo attraverso la stessa sequenza. Quello di sinistra verrà portato altrove. Questo ci dà un ciclo, che decrementa l'input della riga di comando una volta per ciclo e innesca un comportamento su ogni ciclo fino a raggiungere lo 0. Quindi, innesca un altro comportamento.

Diamo un'occhiata a cosa succede con il marmo inserito in @4ogni anello.

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

Ci sono 3 letterali linguistici qui ( FF), che cadranno immediatamente nei portali. Questi portali li porteranno su tre dei IIdispositivi. IIsi riferisce alla scheda :Idefinita più in basso nel file. Poiché :Iha 2 dispositivi di input distinti, la sua rappresentazione su un'altra scheda deve essere larga 2 celle. Dal momento che abbiamo 6 celle contenentiII , diciamo che abbiamo 3 istanze di questa funzione sulla scheda.

I FFmarmi (o 256 o -1 se vuoi) rimarranno nelle celle di input della :Ifunzione in attesa fino a quando non ci sono abbastanza input marmo per avviare la funzione (un altro che è). È qui che @4entra in gioco il portale. Una copia dell'input della riga di comando decrementato cade lì su ogni loop. Questo attiverà la :Itavola più a sinistra . Inizialmente con i valori 256 (o -1) e qualunque sia l'input della riga di comando era -1. Il marmo sinistro verrà inserito nei }0dispositivi del :Itabellone e quello destro nel }1. Se ricordi cosa ha fatto questa tavola, sarai in grado di dire quale risultato ha avuto. Produrrà una versione incrementale dell'ingresso destro sull'uscita sinistra (e trasforma un 9 in uno 0, non 10) e produce 1 o -9 a destra.

Il valore incrementato verrà riportato alla cella di input corretta da un portale e il valore a destra verrà inserito in un sincronizzatore. Se un sincronizzatore tiene già un marmo, i due marmi si scontreranno. I marmi in collisione vengono aggiunti insieme modulo 256. Quindi i valori nei sincronizzatori faranno il folowing: iniziano vuoti, quindi si trasformano in 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 e quindi in 1 di nuovo (dal 247 viene aggiunto il modulo 256).

Potresti anche ricordare che un marmo ottiene l'output a destra quando il valore di input ritorna a 0. Poiché le :Ischede sono una accanto all'altra, ciò farà scattare la scheda a destra una volta. Ciò riempirà i tre sincronizzatori con valori uno superiore a quello che dovrebbero essere per essere una rappresentazione shortlex dell'input della riga di comando, quando questo sarà passato a 0.

Potresti anche ricordare che la :Ofunzione trasforma un valore nel valore ASCII della cifra che rappresenta il valore -1. L'output di queste OOcelle cadrà quindi dalla scheda, che stampa i loro caratteri ascii corrispondenti su STDOUT.

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

Quindi cosa succede quando la riga di comando in input marmo raggiunge 0 e riempie i &0sincronizzatori? bene, alcuni marmi di valore 0 cadono e attivano i tre sincronizzatori che tengono le cifre (+ 1) del numero shortlex nella parte inferiore della scheda. &3viene attivato per primo, poiché contiene la cifra più significativa, quindi viene &2seguito da &1. Questo marmo viene quindi teletrasportato sull'altro @5dispositivo prima di colpire la !!cella, che termina la scheda.

CJam, 14 11 byte

l40f-Ab)s1>

Provalo online.

Come funziona

Questo approccio è fortemente basato sulla risposta di edc65 (con il suo esplicito permesso ):

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

Esempio di esecuzione

$ 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

Python 2 (38) (43)

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

Nessuna sostituzione di personaggio, solo aritmetica.

Ungolfed:

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

Non ho una buona ragione per cui la ricorsione funzioni, ho semplicemente adattato questo schema all'elenco dei valori. Se cambiassi ciascuno n-1in n, otterresti la normale rappresentazione delle cifre.

Per giocare a golf, io uso ~-nper calcolare n-1con precedenza superiore /10o %10, risparmiando sui parentesi. L' n*'_'è solo per produrre la stringa vuota quando n=0e qualsiasi altra stringa altrimenti. La '_'può essere qualsiasi stringa per questo scopo.

Rubino, 70 68 66 64 57 byte

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

Definisce una funzione da chiamare come f[42]. Ecco la suddivisione approssimativa dell'algoritmo:

• Trattare 0separatamente.
• Sottrai i poteri di 10 fino a quando il prossimo potere di 10 non rientra più nel numero.
• Trasforma il numero in una stringa riempita con zeri a sinistra.

I crediti per l'idea di utilizzare una stringa di formato vanno a Falko!

In alternativa, usando l'approccio di edc65:

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

Sono 45 byte e lo sto solo includendo, perché non lo sto battendo. ;)

Haskell, 67 byte

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

questa soluzione aggiunge sostanzialmente 1 il dato numero di volte, in notazione shortlex.

utilizzo:

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

CJam, 16 byte

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

Provalo online. Richiede almeno O (n) tempo e memoria, quindi lascia 100501 all'interprete offline ...

Come funziona

L'idea alla base di questo approccio è quella di calcolare almeno N decimali shortlex nel loro ordine naturale e scartare tutti tranne l'Nth. Non molto efficiente, ma breve.

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.                                       ";

Esempio di esecuzione

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

La risposta intelligente di Port of @ edc65 , con i miglioramenti di @ Dennis :

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

Produzione:

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

Risposta precedente:

Bash + coreutils, 71 54 byte

Ecco un modo leggermente diverso per farlo:

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

• jot genera numeri interi esadecimali crescenti
• tr converte questo in (0,1, ..., 8,9, b, ... f, 0a, 00,01, ..., 99,9b, ..., ff, 0aa, ..., 000 , ...)
• grep filtra semplicemente tutte le righe contenenti cifre da dare (0,1, ..., 8,9,00, ..., 99.000 ....)
• sed elimina tutto tranne l'ennesima riga
• STDERR viene reindirizzato a un file usa e getta '-' in modo da ottenere semplicemente la stringa vuota quando viene passato 0 ( sedconta i numeri di riga che iniziano da 1, quindi errori se viene passato 0)
• Poiché stiamo filtrando i numeri con grep, dobbiamo generare più numeri interi di base 11 con seq/ dcrispetto al numero di input. Ripetere le cifre di n è più che sufficiente.

Si noti che una volta stampato il numero shortlex, seqcontinua a generare numeri fino a $1$1, che rallentano soprattutto per numeri di input più grandi - O (n²), credo. Possiamo accelerare facendo sequscire immediatamente dopo la stampa al costo di 7 byte:

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

Non ci sono requisiti di velocità nella domanda, quindi vado con la versione più breve per la mia risposta principale.

Python 2 - 84, 70 66

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

Approccio alternativo (stessa lunghezza):

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

Python 3, 107 caratteri

Questo non è finito vincendo, ma ho pensato che fosse intelligente:

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]

Definisco un generatore per l'intera sequenza in 64 caratteri. Sfortunatamente, devo passare attraverso alcune contorsioni per ottenere l'ennesimo elemento del generatore ... se solo potessi farlo S=lambda n:G()[n].

Pyth , 12

Un'altra porta della risposta di @ edc65, che è il vincitore chiaro (IMO):

t`+hQv*l`Q\8

Pacchetto di prova (grazie 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"

Spiegazione:

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 byte

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

La straordinaria risposta JavaScript (ES6) di Port di @ edc65 , dal momento che dubito che in Java possa essere fatto in modo aritmetico più breve.

Provalo qui.

Haskell , 57 byte

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

Provalo online!

Costruisce un elenco infinito di numeri shortlex e indici per la risposta. g ncostruisce l'ennesima "generazione" di numeri anteponendo la cifra successiva davanti a ciascuno dei numeri della generazione precedente.

05AB1E , 7 byte

Usa la sostituzione di edc65 con 8 prese

8sg×+>¦

Provalo online!

Spiegazione

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

Excel, 37 byte

Utilizzando l'approccio di @ edc65:

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

Gelatina , 5 byte

ḃ⁵ịØD

Provalo online!

Sono molto nuovo con Jelly, quindi se puoi migliorare questo, per favore commenta!

Spiegazione:

ḃ⁵ịØ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)

(Secondo il commento di res sopra, il problema è equivalente a convertire il numero in base biiettiva 10)