Sebagian besar komputer menyimpan bilangan bulat dalam biner, tetapi mengeluarkannya dalam bentuk desimal. Namun, desimal hanyalah satu representasi, kami kebetulan merasa nyaman.

Tantangan ini adalah menulis beberapa kode untuk menghasilkan nilai integer dalam desimal shortlex .

Apa itu?
http://en.wikipedia.org/wiki/Shortlex_order

Shortlex mengambil panjang urutan angka sebagai penanda utama nilai. Urutannya, mulai dari string kosong yang mewakili nol, adalah ...

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

(Pikirkan kolom Excel, tetapi hanya menggunakan angka desimal.)

Tulis program atau fungsi yang menerima integer dan mengembalikan string yang sesuai dengan representasi shortlex-desimal integer seperti yang dijelaskan di atas.

Nilai tes:

0 → "" (string kosong)
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)

Tes di konsol FireFox

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

Keluaran

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

Bagaimana saya memikirkan hal ini?

Dengan jumlah digit yang tetap, urutan output naik, sehingga ada delta tetap antara input dan output. Lihat:

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

Tetapi 0s terkemuka sulit untuk dikelola, jadi saya punya trik standar, tambahkan digit pertama dan modulo kerja (yaitu, potong digit pertama dalam output). Lalu -1-> +9, -11 -> +89, -111 -> +889 dan seterusnya.
Langkah terakhir: Saya tidak peduli apa angka pertama, jadi tidak perlu memeriksa apakah nomor iinput <atau> dari 111 ... (jujur ​​saya menemukan ini dengan coba-coba)

Uji

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

Ini hanya berfungsi untuk nilai di bawah 256 karena Marbelous adalah bahasa 8 bit.

Bagaimana itu bekerja

Marbelous adalah bahasa 2D dengan nilai-nilai yang diwakili oleh kelereng 8 bit yang jatuh satu sel pada setiap centang kecuali beberapa perangkat mencegahnya jatuh. Program Marbelous ini terdiri dari 3 papan; mari kita mulai dengan yang termudah:

:O
}0
+Z
+C
{0

:Oadalah nama papan (tepatnya, O adalah nama dan: memberi tahu yang ditafsirkan bahwa baris ini adalah nama. Dengan memberi papan nama, papan lain dapat memanggil mereka }0adalah perangkat input, ini dapat dilihat sebagai argumen fungsi ini. Sel ini akan digantikan oleh marmer input (nilai) ketika fungsi dipanggil. +ZMenambahkan 35 ke marmer yang melewatinya dan membiarkannya jatuh. Melakukan +Chal yang sama tetapi hanya menambahkan 12. {0adalah sel output , ketika marmer mencapai sel ini, fungsi akan keluar dan mengembalikan nilai pada perangkat output ini.

Jadi, secara keseluruhan, board ini mengambil satu nilai dan kemudian menambahkan 47 nilai untuknya. Bagi kami, ini berarti mengubah angka satu digit menjadi kode ascii dari digit -1 (ini tentu saja juga berlaku untuk 10).

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

Papan ini terlihat sedikit lebih rumit. Anda harus dapat mengidentifikasi :Isebagai nama board dan telah melihat beberapa perangkat input dan output. Anda akan melihat bahwa kami memiliki dua perangkat input yang berbeda, }0dan }1. Ini berarti fungsi ini membutuhkan 2 input. Anda juga akan melihat bahwa ada dua contoh }1perangkat. Saat memanggil fungsi, kedua sel ini akan berisi nilai yang sama. Perangkat }0input langsung di atas \/perangkat, ini bertindak sebagai tempat sampah dan menghilangkan marmer yang jatuh di atasnya segera.

Mari kita lihat apa yang terjadi pada salah satu kelereng yang diletakkan di papan oleh }1perangkat input:

}1
=9 &1
&0
{>

Ini akan jatuh pada centang pertama dan tekan =9perangkat. Ini membandingkan nilai dari marmer sampai 9 dan membiarkan marmer itu jatuh jika pernyataannya =9dievaluasi. Marmer didorong ke kanan jika tidak. &0dan &1merupakan sinkronisasi. Mereka berpegang pada kelereng yang jatuh ke mereka sampai semua &nsinkronisasi lainnya diisi juga. Seperti yang dapat Anda harapkan, ini akan memicu perilaku yang berbeda pada beberapa bagian lain dari papan.

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

Jika saya memberi tahu Anda bahwa itu ++adalah incrementor, Anda seharusnya sudah dapat mengetahui apa yang akan diisi oleh berbagai sinkronisasi. Kiri &1akan berisi nilai input }1+ 1, di &0sebelahnya akan berisi 0 ( 00adalah bahasa literal, diwakili dalam heksadesimal). Yang kedua &1akan berisi nilai 1 dan hak &0terisi dengan F7, yang mengurangi 9 dari nilai karena penambahan di Marbelous adalah modulo 256.

// adalah alat deflektor, yang mendorong marmer ke kiri alih-alih membiarkannya jatuh.

Menyatukan semua ini memberi Anda ini: jika marmer di }1angka 9, &0sinkronisasi akan terisi. Ini akan menyebabkan nilai 0 jatuh ke dalam {0output dan F7(atau -9) ke dalam {1output. Jika }1bukan 9, {0akan diisi dengan }1+1 dan {0akan berisi 1. Ada juga {>perangkat, ini adalah output khusus yang mengeluarkan marmer di sebelah papan sebagai ganti dari di bawahnya. Ini akan diisi }1jika sama dengan 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

Oke, sekarang untuk yang besar. Papan ini tidak memiliki nama eksplisit, karena ini adalah papan utama file. Nama tersiratnya adalah Mb. Anda harus dapat mengenali beberapa sel. Ada perangkat input, beberapa literal bahasa ( 00dan FF). Ada beberapa sinkronisasi dan ada deflektor. mari kita selangkah demi selangkah demi selangkah.

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

Jadi nilai input (input baris perintah karena ini adalah papan utama) dimulai pada sel kedua dari atas di mana }0berada. Ini akan jatuh dan mencapai >0perangkat, yang merupakan perangkat pembanding lain. setiap marmer yang lebih besar dari 0 jatuh, setiap marmer lainnya terdorong ke kanan. (Karena variabel Marbelous tidak ditandatangani, hanya tepat 0 yang akan didorong ke kanan). Marmer bernilai nol ini kemudian akan mengenai @6perangkat. Ini adalah portal dan mengangkut marmer ke portal terkait lainnya, dalam hal ini tepat di atasnya. Marmer 0 kemudian akan mencapai &0sinkronisasi dan memicu beberapa hal di tempat lain.

Jika marmer bukan 0, jatuh, dibelokkan ke kanan oleh \\hit --yang menurunkannya satu dan kemudian jatuh /\, cloner. Perangkat ini mengambil marmer dan mengeluarkan satu salinannya ke kanan dan satu lagi ke kiri. Yang kiri akan dibawa ke atas ke yang lain di @0mana marmer akan melalui urutan yang sama lagi. Yang kiri akan dibawa ke tempat lain. Ini memberi kita satu loop, yang mengurangi input baris perintah satu kali per loop dan memicu beberapa perilaku pada setiap loop hingga mencapai 0. Kemudian memicu beberapa perilaku lainnya.

Mari kita lihat apa yang terjadi dengan marmer yang didorong ke dalamnya @4 pada setiap loop.

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

Ada 3 literal bahasa di sini ( FF), yang akan segera jatuh ke portal. Portal-portal ini akan membawanya ke tiga IIperangkat.IImerujuk ke papan yang :Ikami definisikan lebih jauh di bawah file. Karena :Imemiliki 2 perangkat input yang berbeda, representasi di papan lain harus selebar 2 sel. Karena kami memiliki 6 sel yang mengandung II, kami dapat memberi tahu kami memiliki 3 contoh fungsi ini di papan tulis.

The FF(atau 256 atau -1 jika Anda akan) kelereng akan duduk di sel input dari :Ifungsi menunggu sampai ada cukup sto masukan marmer memulai fungsi (satu lagi yang). Di situlah @4portal masuk. Salinan input baris perintah menurun jatuh di sana pada setiap loop. Ini akan memicu :Ipapan paling kiri . Initialy dengan nilai 256 (atau -1) dan apa pun input baris perintah adalah -1. Marmer kiri akan dimasukkan ke dalam }0perangkat :Ipapan dan yang tepat ke dalam }1. Jika Anda ingat apa yang dilakukan papan ini, Anda akan dapat mengetahui hasil apa yang dimilikinya. Ini akan menampilkan versi tambahan dari input kanan pada output kiri (dan mengubah 9 menjadi 0, bukan 10) dan menghasilkan 1 atau -9 di sebelah kanan.

Nilai yang bertambah akan dibawa kembali ke sel input kanan oleh portal, dan nilai di sebelah kanan jatuh ke sinkronisasi. Jika sinkronisasi sudah memegang marmer, kedua kelereng akan bertabrakan. Kelereng yang bertabrakan dapat ditambahkan bersama-sama modulo 256. Jadi nilai-nilai di synchroizers akan melakukan berikut: Mereka mulai kosong, kemudian beralih ke 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, dan kemudian ke 1 lagi (sejak 247 ditambahkan modulo 256).

Anda juga mungkin ingat bahwa marmer mendapatkan output ke kanan ketika nilai input kembali ke 0. Karena :Ipapan tepat di sebelah satu sama lain, ini akan memicu papan ke kanan sekali. Ini akan mengisi tiga sinkronisasi dengan nilai-nilai yang satu lebih tinggi dari yang seharusnya menjadi representasi shortlex dari input baris perintah, pada saat ini telah diturunkan ke 0.

Anda mungkin juga ingat bahwa :Ofungsi mengubah nilai menjadi nilai ascii digit yang mewakili nilai -1. Output dari OOsel - sel ini kemudian akan jatuh dari papan, yang mencetak karakter ascii yang sesuai untuk STDOUT.

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

Jadi apa yang terjadi ketika marmer input baris perintah mencapai 0 dan mengisi &0sinkronisasi? nah, beberapa kelereng nilai 0 jatuh dan memicu tiga sinkronisasi yang menahan angka (+ 1) dari nomor shortlex di bagian bawah papan. &3dipicu terlebih dahulu, karena mengandung digit paling signifikan, kemudian &2diikuti oleh &1. Marmer ini kemudian dipindahkan ke @5perangkat lain sebelum akhirnya mengenai !!sel, yang mengakhiri papan.

CJam, 14 11 byte

l40f-Ab)s1>

Cobalah online.

Bagaimana itu bekerja

Pendekatan ini sangat didasarkan pada jawaban edc65 (dengan izin eksplisitnya ):

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

Contoh dijalankan

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

Tidak ada substitusi karakter, hanya aritmatika.

Tidak Disatukan:

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

Saya tidak punya alasan bagus mengapa rekursi bekerja, saya hanya mencocokkan pola ini dengan daftar nilai. Jika Anda mengubah masing-masing n-1ke n, Anda akan mendapatkan representasi digit reguler.

Untuk bermain golf, saya menggunakan ~-nuntuk menghitung n-1dengan prioritas lebih tinggi dari /10atau %10, menghemat pada parens. The n*'_'hanya untuk menghasilkan string kosong ketika n=0dan string lain sebaliknya. The '_'dapat berupa string apapun untuk tujuan ini.

Ruby, 70 68 66 64 57 byte

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

Mendefinisikan fungsi yang disebut like f[42]. Berikut adalah uraian kasar dari algoritma tersebut:

• Memperlakukan 0 secara terpisah.
• Kurangi kekuatan 10 hingga kekuatan 10 berikutnya tidak cocok dengan angka lagi.
• Ubah nomor menjadi string yang diisi dengan angka nol di sebelah kiri.

Kredit untuk gagasan menggunakan string format, buka Falko!

Atau, gunakan pendekatan edc65:

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

Itu 45 byte dan saya hanya memasukkannya, karena saya tidak mengalahkannya dengan itu. ;)

Haskell, 67 byte

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

solusi ini pada dasarnya menambahkan 1 berapa kali, dalam notasi shortlex.

pemakaian:

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

CJam, 16 byte

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

Cobalah online. Membutuhkan setidaknya O (n) waktu dan memori, jadi tinggalkan 100501 ke penerjemah offline ...

Bagaimana itu bekerja

Ide dasar di balik pendekatan ini adalah untuk menghitung setidaknya N desimal pendek dalam tatanan alami mereka dan membuang semua kecuali N. Tidak terlalu efisien, tetapi pendek.

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

Contoh dijalankan

$ 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

Port jawaban cerdas @ edc65 , dengan peningkatan @ Dennis :

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

Keluaran:

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

Jawaban sebelumnya:

Bash + coreutils, 71 54 byte

Berikut cara yang sedikit berbeda untuk melakukannya:

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

• jot output meningkatkan bilangan bulat heksadesimal
• tr ubah ini menjadi (0,1, ..., 8,9, b, ... f, 0a, 00,01, ..., 99,9b, ..., ff, 0aa, ..., 000 , ...)
• grep cukup filter semua garis yang mengandung digit untuk memberi (0,1, ..., 8,9,00, ..., 99.000 ....)
• sed menghapus semua kecuali baris ke-n
• STDERR dialihkan ke file yang dibuang '-' sehingga kita cukup mendapatkan string kosong ketika 0 diteruskan ( sedmenghitung angka garis mulai dari 1, jadi kesalahan jika 0 dilewatkan)
• Karena kita memfilter angka keluar grep, kita perlu menghasilkan lebih banyak basis 11 integer dengan seq/ dcdaripada nomor input. Mengulang digit n lebih dari cukup.

Perhatikan bahwa setelah nomor shortlex dicetak, seqterus menghasilkan angka hingga $1$1, yang lambat terutama untuk nomor input yang lebih besar - O (n²), saya pikir. Kita dapat mempercepat dengan seqmenghentikannya segera setelah mencetak dengan biaya 7 byte:

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

Tidak ada persyaratan kecepatan dalam pertanyaan, jadi saya akan menggunakan versi yang lebih pendek untuk jawaban utama saya.

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)

Pendekatan alternatif (panjang yang sama):

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

Python 3, 107 karakter

Ini tidak berakhir dengan kemenangan tetapi saya pikir itu pintar:

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]

Saya mendefinisikan generator untuk seluruh urutan dalam 64 karakter. Sayangnya, saya harus melalui beberapa contortions untuk mendapatkan elemen ke-n dari generator ... kalau saja saya bisa melakukannya S=lambda n:G()[n].

Pyth , 12

Port lain dari jawaban @ edc65, yang merupakan pemenang yang jelas (IMO):

t`+hQv*l`Q\8

Paket tes (Terima kasih kepada @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"

Penjelasan:

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)

Port dari JavaScript menakjubkan (ES6) jawaban @ edc65 , karena saya ragu itu bisa dilakukan lebih pendek dengan cara aritmatika di Jawa.

Coba di sini.

Haskell , 57 byte

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

Cobalah online!

Buatlah daftar nomor pendek yang tak terhingga dan buat indeks untuk jawabannya. g nmembangun "generasi" angka ke-n dengan memprioritaskan digit berikutnya di depan setiap angka pada generasi sebelumnya.

05AB1E , 7 byte

Menggunakan edc65 diganti dengan 8 trik

8sg×+>¦

Cobalah online!

Penjelasan

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

Excel, 37 byte

Menggunakan pendekatan @ edc65:

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

Jelly , 5 byte

ḃ⁵ịØD

Cobalah online!

Saya sangat baru mengenal Jelly, jadi jika Anda dapat meningkatkan ini, beri komentar!

Penjelasan:

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

(Menurut komentar res di atas, masalahnya setara dengan mengubah nomor menjadi basis bijective 10)