Il numero di Rien


38

La costante di Champernowne è un numero che viene costruito concatenando i primi nnumeri, con ntendenza all'infinito. Sembra qualcosa del genere:

0.123456789101112131415161718192021222324252627282930...

Ora, ti descriverò il numero di Rien . Può essere pensato come una minimizzazione della costante di Champernowne come un numero intero. Mi riferirò al numero di Rien con le prime ncifre come Ri ( n ). Ecco come formularlo:

  1. I primi nnumeri naturali (la sequenza {1,2,3, ...}) sono concatenati.
  2. Questo risultato viene quindi ordinato, in base al valore della cifra. Quindi 1..12sembrerebbe 011111223456789.
  3. Poiché il Rien numero non può avere zeri, abbiamo spostare tutti 0s in modo che siano significativi, pur mantenendo il numero minimizzato, conseguente, ad esempio, 101111223456789. Questo è Ri ( n ), in questo caso, Ri (12).

Ecco alcuni risultati per Ri ( n ):

n     Ri ( n )
1 1
2 12
3 123
7 1234567
9 123456789
10 10123456789
15 101111111223344556789
34 10001111111111111222222222222223333333334444555666777888999
42 10000111111111111112222222222222223333333333333333444444455556666777788889999
45 10000111111111111112222222222222223333333333333333344444444444555556666777788889999
55 10000011111111111111122222222222222223333333333333333444444444444444455555555555566666777778888899999
100 1000000000001111111111111111111122222222222222222222333333333333333333334444444444444444444455555555555555555555556666666666666666666666777777777777777777778888888888888888888899999999999999
999100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999

Obiettivo Dato un numero 1 ≤ n<10000 come input (tramite argomenti, STDIN o hardcoding se la tua lingua non supporta input convenzionali), output / return Ri ( n).

Questo è un , quindi vince il codice più breve in byte. Puoi usare una lingua creata dopo questo concorso, purché non sia stata creata per rispondere a questa sfida. (Certo, puoi usarlo, se fornisce una soluzione interessante, ma segna la tua risposta come non competitiva.)

Implementazione di riferimento

Ho provato questo in IE, quindi non dovrebbe esserci un problema. Se c'è un problema, c'è una soluzione facile: ottenere un browser sano di mente.

function min(n) {
  var seq = [];
  for(var i = 1; i <= n; i++) seq.push(i);
  seq = seq.join("").split("").map(Number);
  var to;
  if(seq.indexOf(1) >= 0) to = seq.splice(seq.indexOf(1), 1);
  seq.sort(function(a, b) {
    return a - b;
  });
  if(to) seq = to.concat(seq);
  return seq.join("");
}
t.onchange = t.onkeyup = function() {
  h.innerHTML = min(this.value)
}
* {
  font-family: Consolas, monospace;
}
input {
  border: 2px dotted #aaaaaa;
  border-radius: 5px;
  margin: 10px;
}
<input id="t" type="number">
<div id="h">


Classifica

Lo snippet di stack nella parte inferiore di questo post genera il catalogo dalle risposte a) come elenco della soluzione più breve per lingua eb) come classifica generale.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

## Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

## Perl, 43 + 2 (-p flag) = 45 bytes

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes


22
Ho sempre pensato che 0fosse il numero di rien .
Flawr

Non sono sicuro che mi manchi qualcosa, ma possiamo semplicemente spostare una delle 1s davanti alla 0s, sì?
FryAmTheEggman,

@FryAmTheEggman Hai ragione.
Conor O'Brien,

@ MartinBüttner \ o / l'hai trovato.
Conor O'Brien,

@ CᴏɴᴏʀO'Bʀɪᴇɴ No, quello era diverso. Quello consentiva solo permutazioni degli interi numeri, non delle loro singole cifre.
Martin Ender,

Risposte:


12

Pyth, 8

+1SjktSQ

Crea un elenco [1, .. , input]quindi rimuove quello principale, unisce e ordina, quindi antepone un 1.

Test Suite


13

Perl, 44 42 41 33 31 byte

Yaaay, primo post in assoluto!

Grazie a primo per il salvataggio di 2 byte.

print 1,sort"@{[2..<>]}"=~/\d/g

Come altri, rimuovere 1 e anteporre manualmente fa il lavoro.

Provalo online


2
Benvenuto in PPCG e congratulazioni per il tuo primo post (anche se mi sembra strano avermi dato il benvenuto, da quando ti sei iscritto prima di me ...). Due cose: conto 43 byte ... secondo, il tuo link "Provalo online" sembra puntare a una revisione precedente / diversa del tuo codice. Copia e incolla manualmente il tuo codice in Ideone funziona, ma non il tuo link.
AdmBorkBork,

Grazie per il tuo commento! Ho usato TextWrangler per il conteggio dei byte, suppongo di essere andato 1 troppo lontano ... (inoltre non era necessario uno spazio, in modo da ridurre l'intero conteggio dei byte a 42). L'Ideone dovrebbe essere risolto ora.
Paul Picard,

Oh, non lo sapevo. Funziona anche sul mio Perl sul mio Mac (5.18) Grazie!
Paul Picard,


2
Salvataggio di due byte eliminando la divisione / join:print 1,sort"@{[2..<>]}"=~/\d/g
primo

11

Japt, 14 12 byte

1+2o°U ¬¬n ¬

Provalo online!

Come funziona

1+2o°U ¬¬n ¬  // Implicit: U = input integer
  2o°U        // Generate the range of integers from 2 to U, inclusive.
       ¬¬     // Join, then split into chars.
         n    // Sort.
1+         ¬  // Join again, and add a 1 to the beginning.
              // Implicit: output last expression

4
o_o hai giocato a golf nel periodo di grazia di 5 minuti? pistola più veloce dell'ovest
Conor O'Brien,

@ CᴏɴᴏʀO'Bʀɪᴇɴ Suppongo che non vorrai postare nuovi codici golf dopo quello: D
Pierre Arlaud

9

Retina , 78 byte

È ora di mostrare alcune nuove funzionalità di Retina (non è ancora molto competitivo, ma prima di oggi probabilmente sarebbe stato più vicino a 300 byte).

.+
$0$*1
\B
 $`
(1)+
$#1
^1| 

.
 1$0$*1
+r`(1+\2) (1+)\b
$2 $1
 1(1)*
$#1
^
1

Provalo online.

Spiegazione

Sebbene sia possibile convertire tra decimale e unario abbastanza comodamente ora, questo è ancora piuttosto lungo perché devo convertire avanti e indietro più volte perché alcune operazioni sono più eseguibili in decimale che in unario e viceversa.

.+
$0$*1

Cominciamo convertendo l'input in unario. Funziona abbinando l'input e quindi usando le $*1ripetizioni 1più volte (questa funzione di ripetizione è nuova a partire da oggi).

\B
 $`

Successivamente, generiamo un intervallo da 1a Nin unario. Ho spiegato perché questo funziona nella mia risposta FizzBuzz .

(1)+
$#1

Convertiamo ogni numero nell'intervallo in decimale in modo da poter lavorare con le cifre decimali. Questo viene fatto abbinando ciascuno dei numeri unari in modo tale che ciascuno 1generi una cattura separata. Quindi lo sostituiamo con il numero di acquisizioni del gruppo uno, utilizzando la nuova sintassi del conteggio delle acquisizioni $#1.

^1| 

In questo modo vengono rimossi gli 1spazi iniziali e iniziali dalla stringa, in modo che restino solo le cifre (tranne una singola 1).

.
 1$0$*1

Convertiamo nuovamente in unario e aggiungiamo 1a ogni cifra (per garantire che anche 0sia un non vuoto). Inseriamo anche uno spazio davanti a ogni cifra per assicurarci che siano separate.

+r`(1+\2) (1+)\b
$2 $1

Abbiniamo ripetutamente un numero piccolo preceduto da un numero più grande e li scambiamo. È una specie di bolla a Retina. :)

 1(1)*
$#1

Aaaand torna al decimale.

^
1

Infine, inseriamo un singolo 1nella parte anteriore per tenere conto di quello che abbiamo rimosso in precedenza.


1
Di quali nuove funzionalità parli?
Conor O'Brien,

1
@ CᴏɴᴏʀO'Bʀɪᴇɴ Aggiungerò una spiegazione in seguito. Questo utilizza una nuova sintassi di sostituzione per il conteggio delle acquisizioni e la ripetizione di caratteri che possono essere utilizzati per una conversione decimale / unaria ragionevolmente breve. Ecco il log delle modifiche
Martin Ender

@ MartinBüttner simpatico. Questo significa che Retina non può più richiedere questa esenzione ?
Trauma digitale

@DigitalTrauma Penso che sia ancora la forma più naturale di input. Inoltre non ho mai capito come quel tipo di linguaggio abbia mai avuto così tanto supporto su questo sito.
Martin Ender,

6

Haskell, 44 byte

import Data.List
f n='1':sort(show=<<[2..n])

Sfortunatamente sortè dentro Data.List, sono 17 byte!


6

JavaScript (ES6), 65 62 54 52 byte

Salvato 3 byte grazie a edc65

x=>eval("for(b='';x>1;)1+[...b+=x--].sort().join``")

Crea una stringa di tutti i numeri da 2 a x, quindi divide, ordina, unisce e aggiunge un 1 all'inizio. Questo può essere ancora golfabile; suggerimenti benvenuti!


Non ho ES6 a portata di mano, ma non puoi semplicemente usare (nuovo) Array(x-1).map((_,y)=>y+2)?
Conor O'Brien,

La mappa @ CᴏɴᴏʀO'Bʀɪᴇɴ salta gli elementi dell'array vuoti, quindi dovresti usare Array(n).fill().map(...(vedi i suggerimenti ES6)
edc65

Troppo tardi per pubblicare il mio, ma un suggerimento per te: n=>1+[...[...Array(n-1)].map(_=>++n,n=1).join``].sort().join`` (1 byte più corto, è la divisione)
edc65

@ edc65 e Cᴏɴᴏʀ O'Bʀɪᴇɴ Grazie per i suggerimenti! Mi chiedevo perché usare si .split()sentisse così strano ...
ETHproductions

@ edc65 Eh, la mia soluzione è della stessa lunghezza della tua:n=>1+[...[...Array(n+1).keys()].slice(2).join``].sort().join``
Neil


5

Mathematica, 52 byte

"1"<>ToString/@Sort[Join@@IntegerDigits[2~Range~#]]&

Ancora una volta, l'elaborazione delle stringhe è avvenuta ...


Penso che IntegerDigitsdiscussioni su elenchi, quindi non è necessario mapparlo.
Martin Ender,

Oh giusto, precedenza.
Martin Ender,

4

APL (17)

'1',∆[⍋∆←1↓∊⍕¨⍳⎕]

Spiegazione:

'1',∆[⍋∆←1↓∊⍕¨⍳⎕]
-----------------
               ⎕   read a number from the keyboard
               ⍳    get the natural numbers up to and including that number
             ⍕¨    get the string representation for each number
           ∊       flatten the array (giving a string of digits)
         1↓        remove the first digit (which is always 1)
       ∆←          store the result in ∆
      ⍋            get a permutation to sort ∆ upwards
    ∆[           ] rearrange ∆ so that it is sorted
'1',               add a 1 to the front

Test:

      '1',∆[⍋∆←1↓∊⍕¨⍳⎕]
⎕:
      1
1
      '1',∆[⍋∆←1↓∊⍕¨⍳⎕]
⎕:
      10
10123456789
      '1',∆[⍋∆←1↓∊⍕¨⍳⎕]
⎕:
      55
10000011111111111111122222222222222223333333333333333444444444444444455555555555566666777778888899999

Bello! Molto meglio del mio. : DI non ha realizzato che avrebbe appiattito l'array e ti avrebbe dato una stringa. Buono a sapersi.
Alex A.

3

Python 2, 60 byte

_="".join;print"1"+_(sorted(_(map(str,range(2,input()+1)))))

3

ClojureScript, 48 byte

#(apply str"1"(sort(apply str(range 2(inc %)))))

Come tutti gli altri, praticamente. REPL disponibile qui .


3

Rubino, 48 byte

Una funzione anonima. Fondamentalmente solo Rubyfied alcune delle altre risposte qui ..

->n{n>1?(?1+[*2..n].join.chars.sort*'').to_i: n}

3

Brachylog , 76 41 byte

1 .;{,1:.e?}?:1fcbZlL,ZoOlM,10^(L-M)=:Oc.

Accetta un numero come input.

Questa soluzione funziona con le poche modifiche che ho apportato al predicato Findall incorporato f . A quanto pare OP è d'accordo con l'uso di lingue più vecchie della risposta, quindi penso che vada bene (le modifiche che ho apportato sono state intese molto tempo fa, mi sono semplicemente motivato a farlo a causa di questa sfida).

Spiegazione

1 .                                            § If the input is 1, unify output with 1

   ;                                           § Else

    {      }?:1f                               § Output a list of all inputs which satisfy
                                               § the predicate in brackets with the input
                                               § of the main predicate (ie the input number)
                                               § as output

     ,1:.e?                                    § True if the input is an integer between 1
                                               § and . (the output)

                cbZ                            § Concatenate everything into a single number,
                                               § remove the first digit (1) and call it Z

                   lL,ZoOlM,                   § L is the length of Z, M is the length of O
                                               § O being Z sorted (which removes the leading
                                               § 0s)

                            10^(L-M)=:Oc.      § Concatenate 10^(L-M) at the beginning of O
                                               § and unify it with the output

3

Smalltalk, 76 byte

Come al solito in Smalltalk, concettualmente molto conciso, ma testualmente molto prolisso ...

f:l^'1',((2to:l)fold:[:p :q|p asString,q asString])asByteArray sort asString

Aggiungi questo come metodo di classe per Stringe chiama in questo modo, ad esempio per 20,String f: 20


3

Utilità Bash + GNU, 58

seq $1|sed 's/./&\n/g'|sort|tr -d \\n|sed 's/\(0*\)1/1\1/'

Provalo online.


1
Avevo un approccio simile, ma una diversa gestione della parte "1 all'inizio" (52 byte). Con i tuoi puoi raderti: ordina (lunga 1 cifra, non c'è bisogno di -n).
Olivier Dulac l'

3

Bash, 35 34 byte

printf %d 1`seq 2 $1|fold -1|sort`

Questo si basa sulle risposte di @DigitalTrauma e @OlivierDulac . Provalo online con Ideone .

Come funziona

  • seq 2 $1stampa tutti i numeri interi da 2 a quello specificato nella riga di comando.

  • fold -1 avvolge tutte le righe con larghezza 1, ovvero posiziona ciascun carattere sulla propria riga.

    -1 sembra essere una caratteristica non documentata.

  • sort ordina i caratteri in base al loro valore numerico.

  • printf %d 1`...`​antepone un 1 alla prima riga e stampa ogni riga come un numero intero (%d ), senza separazione.

    Questo sfrutta la curiosa implementazione di printf di Bash, che ripete ripetutamente la stringa di formato, fino a quando tutti gli argomenti non vengono consumati.


+1, mi piace quello migliore del nostro :)
Olivier Dulac il

3

JavaScript ES6, 49 46 byte

Grazie a edc65 per 2 byte

F=
x=>1+[...(g=_=>x>1?x--+g``:_)``].sort().join``

;console.log(F(15))


1
Ho qualcosa di simile ma più corto di 1 byte. Prova a utilizzare una funzione ricorsiva senza argomenti, semplicemente diminuendo il parametro originale x
edc65

2

Julia, 33 byte

n->"1"*join(sort([join(2:n)...]))

Questa è una funzione lambda che accetta un numero intero e restituisce una stringa. Per chiamarlo, assegnarlo a una variabile.

Costruiamo l'intervallo 2:n, che sarà vuoto per n<2, lo uniamo in una stringa, suddividiamo la stringa in una matrice di caratteri, li ordiniamo, uniamo in una stringa e anteponiamo 1.


2

APL, 21 byte

{' '~⍨⍕1,x[⍋x←⍕1↓⍳⍵]}

Questa è una funzione monadica senza nome che accetta un numero intero sulla destra e restituisce una stringa. Per chiamarlo, assegnarlo a una variabile.

Spiegazione:

            x←⍕1↓⍳⍵]}   ⍝ Get the numbers 1:input, drop 1, convert to string
         x[⍋            ⍝ Sort
      ⍕1,               ⍝ Tack 1 onto the front, flatten to string
{' '~⍨                  ⍝ Remove the spaces (side effect of ⍕ on an array)

Provalo online


2

Python 2, 60 byte

P=input();print"1"+"".join(sorted(`range(2,P+1)`)[P*2-4:-2])

Indicizzazione per la vittoria. :-)


Python 2, 60 byte

P=input();print"1"+"".join(sorted(`range(-P,-1)`))[P*3-5:-2]

Solo un'alternativa.


2

Via Lattea 1.6.4 , 22 byte (non in competizione)

^^'LH=^^JB", "-Q"1";+!

Ho dovuto aggiungere un codice operativo di ordinamento per questa sfida.


Spiegazione

^^                      ` pop the TOS
  '                     ` read input from the command line
   LH                   ` push a reversed Pythonic range(TOS+1)
     =^^J               ` remove the top 2 items from the TOS
         B              ` push the string literal of the TOS
          ", "-         ` remove ", " from the TOS
               Q        ` sort the TOS
                "1";+   ` add "1" to the beginning of the TOS
                     !  ` output the TOS

2

Scherzi a parte, 10 byte

,u2xεjS'1+

Dump esadecimale:

2c753278ee6a5327312b

Provalo online

Spiegazione:

,            Read input
 u2x         Push range from 2..n
    εj       Join into string
      S      Sort
       '1+   Prepend a "1"

2

Strumenti di Bash e GNU, 58 52 byte

echo 1$(seq 2 $1|sed -e 's/./&\n/g'|sort|tr -d \\n)

approccio simile a @ Digital-trauma, ma un modo diverso di aggiungere 1, e non c'è bisogno di -n poiché i numeri sono lunghi 1 cifra. (Ho visto la sua risposta dopo aver fatto il mio primo tentativo)
Olivier Dulac l'

2

PowerShell, 61 59 byte

param($a)(("1"+-join([char[]]-join(2..$a)|sort)),1)[$a-eq1]

Accetta l'input param($a)e quindi lo utilizza per indicizzare in un array con [$a-eq1]. Se vero, indicizziamo il secondo elemento e l'output1 . Altrimenti, ci concateniamo "1"con l' joinarray ed creato da 1) definendo un nuovo intervallo 2..$ache è stato messo joininsieme, 2) lanciandolo come un array di caratteri e 3) inviandolo attraverso ilSort-Object cmdlet, che viene quindi emesso.

Modifica1: salvato 2 byte spostando l'interno -join operatore .


2

Gogh , 9 7 byte

GJT1-1P

Puoi eseguirlo usando:

$ ./gogh noi 'GJT1-1P' <input>

G     “ Push a range (1, TOS]       ”
J     “ Join the TOS                ”
T     “ Sort the TOS                ”
1-    “ Remove the first 1          ”
P     “ Prepend the TOS to the STOS ”

"Puoi usare una lingua creata dopo questo concorso, purché non sia stata creata per rispondere a questa sfida." Consento a queste lingue di essere competitiva nelle mie sfide, di solito;)
Conor O'Brien,

@ CᴏɴᴏʀO'Bʀɪᴇɴ: Oh, fantastico! Grazie per averlo segnalato :)
Zach Gates,

2

Gelatina , 8 byte

RDFṢ1œ|Ḍ

Provalo online!

Come funziona

RDFṢ1œ|Ḍ  Main link. Argument: n (integer)

R         Range; yield r := [1, ..., n].
 D        Convert each k in r into the array of its digits in base 10.
  F       Flatten the resulting array of lists.
   Ṣ      Sort the resulting flat list of digits.
    1œ|   Perform multiset union with 1 as left argument.
          This moves a single 1 to the beginning of the list.
       Ḍ  Convert the resulting list of base 10 to integer.

2

Oracle SQL 11.2, 222 211 byte

SELECT 1||TRIM(xmlagg(xmlelement(e,c)).EXTRACT('//text()'))FROM(SELECT SUBSTR(s,LEVEL+2,1)c FROM(SELECT MAX(sys_connect_by_path(LEVEL,' '))s FROM DUAL CONNECT BY LEVEL<=:1)CONNECT BY LEVEL<=LENGTH(s)ORDER BY 1);

Un-golfed

SELECT 1||TRIM(xmlagg(xmlelement(e,c)).EXTRACT('//text()'))  -- add leading 1, concatenate each char and remove spaces
FROM   (
         SELECT SUBSTR(s,LEVEL+2,1)c                          -- split the string in characters, omiting the first number (1)   
         FROM   (
                  SELECT MAX(sys_connect_by_path(LEVEL,' '))s -- create a string by concatenating numbers
                  FROM   DUAL 
                  CONNECT BY LEVEL<=:1
                )
         CONNECT BY LEVEL<=LENGTH(s)ORDER BY 1
       )

2

MATL , 17 byte

Utilizza la versione corrente (7.0.0) di lingua / compilatore.

49[]i:"@YUh]6L)Sh

Ispirato dalla risposta di FryTheEgggman .

MODIFICA (29 luglio 2016): puoi provarlo online con alcune modifiche per adeguarti ai cambiamenti nella lingua.

Esempio

>> matl
 > 49[]i:"@YUh]6L)Sh
 >
> 12
101111223456789

Spiegazione

49        % push '1'
[]        % push empty array
i:        % input "N" and build vector [1, 2, ... N]
"         % for each number in this vector
   @      % push that number
   YU     % convert to string
   h      % concatenate horizontally
]         % end
6L)       % remove first element
S         % sort
h         % concatenate horizontally

1

05AB1E , 6 byte

Nota: questa presentazione utilizza funzionalità che postdatano questa sfida e pertanto non è competitiva

Codice:

Lß?J{?

Spiegazione:

L      # Creates the list [1 .. input]
 ß     # Extract the smallest value of the list
  ?    # Print this value (always 1)
   J   # ''.join(list)
    {  # Sort the string
     ? # Print this value

Utilizza la codifica ISO 8859-1


Come funziona?
lirtosiast

@ThomasKwa Spiegazione aggiunta
Adnan,

Whoa. È fantastico!
Conor O'Brien,

1

Mathcad, 86 "byte"

La funzione s (n) usa un ciclo for per costruire il "numero intero" di Champernowne convertendo ogni numero nella sua forma di stringa e concatenandoli insieme. La stringa viene quindi convertita nel suo vettore equivalente di codici ASCII e ordinata. La funzione quindi scambia eventuali zeri iniziali con il primo, convertendo infine il vettore in una stringa.

Per verificare la funzione, ho inserito i casi di test in un vettore vn, quindi ho applicato s a vn utilizzando l'operatore vectorize. Quindi controllo i risultati rispetto ai valori indicati nel caso di test.

enter image description here


Mathcad è un'applicazione matematica basata su fogli di lavoro 2D composti da "regioni", ciascuna delle quali può essere un testo, un'espressione matematica, un programma, una trama o un componente scritto.

Un'istruzione matematica o di programmazione viene scelta da una barra degli strumenti della tavolozza o immessa utilizzando una scorciatoia da tastiera. Ai fini del golf, si considera un'operazione ("byte") il numero di operazioni da tastiera necessarie per creare un nome o un'espressione (ad esempio, per impostare la variabile a su 3, scrivere a: = 3. L'operatore di definizione : = è un singolo tasto ":", così come a e 3 per un totale di 3 "byte". La programmazione per l'operatore richiede di digitare ctl-shft- # (o un singolo clic sulla barra degli strumenti di programmazione), quindi equivale di nuovo a 1 byte.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.