Le nombre rien

38

La constante de Champernowne est un nombre qui est construit en concaténant les premiers nnombres, avec une ntendance à l'infini. Cela ressemble à quelque chose comme ça:

0.123456789101112131415161718192021222324252627282930...

Maintenant, je vais vous décrire le numéro Rien . Cela peut être considéré comme une minimisation de la constante de Champernowne comme un entier. Je ferai référence au numéro Rien avec les premiers nchiffres comme Ri ( n ). Voici comment le formuler:

  1. Les premiers nnombres naturels (la séquence {1,2,3, ...}) sont concaténés.
  2. Ce résultat est ensuite trié en fonction de la valeur numérique. Donc 1..12, ressemblerait 011111223456789.
  3. Étant donné que le Rien nombre ne peut pas avoir des zéros, nous passons tous 0s afin qu'ils soient importants, tout en gardant le nombre réduit, ce qui , par exemple, 101111223456789. C'est Ri ( n ), en l'occurrence Ri (12).

Voici quelques résultats pour Ri ( n ):

n     Ri ( n )
1 1
2 12
3 123
7 1234567
9 123456789
10 10123456789
15 101111111223344556789
34 10001111111111111222222222222223333333334344545666777888999
42 1000011111111111122222222222222333333333333334444455556666777788889999
45 1000011111111111122222222222222333333333333333434444444555556666777788889999
55 100000111111111111122222222222222333333333333333344
100 100000000000111111111111111122222222222222222222333333333333333333334444444444444444444545555555555555555556666666666666666666666666667676777777777777777997799779977999999
999100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999

Objectif Étant donné un nombre 1 ≤ n<10000 en entrée (via des arguments, STDIN ou codage en dur si votre langue ne prend pas en charge les entrées classiques), output / return Ri ( n).

Ceci est un , donc le code le plus court en octets gagne. Vous pouvez utiliser une langue qui a été créée après ce concours, à condition que cela n’ait pas été fait pour répondre à ce défi. (Bien sûr, vous pouvez l' utiliser si cela apporte une solution intéressante, mais indiquez que votre réponse est non concurrente.)

Mise en oeuvre de référence

J'ai testé cela dans IE, donc il ne devrait vraiment pas y avoir de problème. S'il est un problème, il y a une solution simple: obtenir un navigateur sain d' esprit.

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


Classement

L'extrait de pile au bas de cet article génère le catalogue à partir des réponses a) sous forme de liste des solutions les plus courtes par langue et b) sous forme de classement global.

Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

## Language Name, N bytes

Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores en les effaçant. Par exemple:

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

Si vous souhaitez inclure plusieurs numéros dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou si vous souhaitez répertorier séparément les pénalités d'indicateur d'interprétation), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de langue un lien qui apparaîtra ensuite dans l'extrait de code:

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

Conor O'Brien
la source
22
J'ai toujours pensé que 0c'est le numéro rien .
Flawr
Je ne sais pas si je manque quelque chose, mais nous pouvons simplement déplacer l'un des 1s devant les 0s, oui?
FryAmTheEggman
@FryAmTheEggman Vous avez raison.
Conor O'Brien
@ MartinBüttner \ o / vous l'avez trouvé.
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Nope celui-là était différent. Celui-ci n'autorisait que les permutations des nombres entiers, pas de leurs chiffres individuels.
Martin Ender

Réponses:

12

Pyth, 8

+1SjktSQ

Crée une liste [1, .. , input]puis supprime le premier, joint et trie, puis ajoute un 1.

Suite de tests

FryAmTheEggman
la source
13

Perl, 44 42 41 33 31 octets

Yaaay, premier post!

Merci à primo pour la sauvegarde de 2 octets.

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

Comme d'autres l'ont fait, supprimer 1 et l'ajouter à la main manuellement fait le travail.

Essayez-le en ligne

Paul picard
la source
2
Bienvenue sur PPCG, et félicitations pour votre premier message (bien que cela me paraisse étrange de vous souhaiter la bienvenue, puisque vous avez rejoint le groupe avant moi ...) Deux choses - je compte 43 octets ... Deuxièmement, votre lien "Essayez-le en ligne" semble pointer vers une révision plus ancienne / différente de votre code. Copier-coller manuellement votre code dans Ideone fonctionne, mais pas votre lien.
AdmBorkBork
Merci pour votre commentaire ! J'ai utilisé TextWrangler pour le compte d'octets, je suppose que je suis allé trop loin ... (plus un espace n'était pas nécessaire, ce qui réduit le nombre total d'octets à 42). L'Ideone devrait être corrigé maintenant.
Paul Picard
Oh, je ne savais pas à ce sujet. Fonctionne également sur mon Perl sur mon Mac (5.18) Merci!
Paul Picard
2
Sauvé deux octets en se débarrassant de la scission / join:print 1,sort"@{[2..<>]}"=~/\d/g
dimanche
11

Japt, 14 12 octets

1+2o°U ¬¬n ¬

Essayez-le en ligne!

Comment ça marche

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
ETHproductions
la source
4
o_o vous avez joué au golf dans la période de grâce de 5 minutes? pistolet le plus rapide de l'ouest
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ J'imagine que vous ne voulez pas poster de nouveaux codes de golf après ça: D
Pierre Arlaud
9

Retina , 78 octets

Il est temps de montrer quelques nouvelles fonctionnalités de Retina (ce n'est pas encore très compétitif, mais avant aujourd'hui, cela aurait probablement été plus proche de 300 octets).

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

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

Essayez-le en ligne.

Explication

Bien qu'il soit possible de convertir très facilement en décimal et en unaire, cela reste néanmoins assez long, car je dois effectuer plusieurs conversions en arrière car certaines opérations sont plus réalisables en décimal qu'en unaire et inversement.

.+
$0$*1

Commençons par convertir l'entrée en unaire. Cela fonctionne en faisant correspondre l'entrée puis en utilisant $*1laquelle répète 1autant de fois (cette fonctionnalité de répétition est nouvelle à ce jour).

\B
 $`

Ensuite, nous générons une plage allant de 1à Nen unaire. J'ai expliqué pourquoi cela fonctionne dans ma réponse à FizzBuzz .

(1)+
$#1

Nous convertissons chaque nombre de la plage en valeurs décimales afin de pouvoir utiliser les chiffres décimaux. Ceci est effectué en comparant chacun des nombres unaires de sorte que chacun 1génère une capture séparée. Ensuite, nous remplaçons cela par le nombre de captures du groupe un, en utilisant la nouvelle syntaxe du nombre de captures $#1.

^1| 

Cela supprime le début 1ainsi que tous les espaces de la chaîne, il ne reste donc que les chiffres (sauf un seul 1).

.
 1$0$*1

Nous reconvertissons en unaires et ajoutons 1à chaque chiffre (pour nous assurer que même 0est un non vide). Nous insérons également un espace devant chaque chiffre pour nous assurer qu'ils sont séparés.

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

Nous comparons à plusieurs reprises un petit nombre précédé d'un nombre plus grand et les échangeons. C'est une sorte de bulle dans la rétine. :)

 1(1)*
$#1

Retour à la décimale.

^
1

Enfin, nous en insérons un 1au début pour rendre compte de celui que nous avons supprimé précédemment.

Martin Ender
la source
1
De quelles nouvelles fonctionnalités parlez-vous?
Conor O'Brien
1
@ CᴏɴᴏʀO'Bʀɪᴇɴ Je vais ajouter une explication plus tard. Celui-ci utilise une nouvelle syntaxe de substitution pour le comptage des captures et la répétition des caractères pouvant être utilisés pour une conversion décimale / unaire raisonnablement courte. Voici le changelog complet: github.com/mbuettner/retina/blob/master/CHANGELOG.md
Martin Ender
@ MartinBüttner sympa. Est-ce que cela signifie que Retina ne peut plus prétendre à cette exemption ?
Digital Trauma
@ DigitalTrauma Je pense que c'est toujours la forme de contribution la plus naturelle. De plus, je n’ai jamais compris comment ce genre de langage a obtenu autant de soutien sur ce site.
Martin Ender
6

Haskell, 44 octets

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

Malheureusement , sortest en Data.List, c'est 17 octets!

nimi
la source
6

JavaScript (ES6), 65 62 54 52 octets

3 octets sauvés grâce à edc65

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

Construit une chaîne de tous les nombres de 2 à x, puis scinde, trie, joint et ajoute un 1 au début. Cela peut encore être golfable; suggestions bienvenues!

ETHproductions
la source
Je n'ai pas l'ES6 sous la main, mais ne pouvez-vous pas simplement utiliser (nouveau) Array(x-1).map((_,y)=>y+2)?
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ map ignorer les éléments de tableau vides, vous devriez donc les utiliser Array(n).fill().map(...(voir astuces sur ES6)
edc65
Trop tard pour poster le mien, mais un indice pour vous: n=>1+[...[...Array(n-1)].map(_=>++n,n=1).join``].sort().join`` (1 octet de moins, c'est la division)
edc65
@ edc65 et Cᴏɴᴏʀ O'Bʀɪᴇɴ Merci pour les conseils! Je me demandais pourquoi l'utilisation .split()était si étrange ...
ETHproductions
@ edc65 Hein, ma solution a-t-elle la même longueur que la vôtre:n=>1+[...[...Array(n+1).keys()].slice(2).join``].sort().join``
Neil
5

Mathematica, 52 octets

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

Une fois encore, le traitement des chaînes de caractères a eu lieu ...

LegionMammal978
la source
Je pense que les IntegerDigitsdiscussions sur les listes vous évitent d'avoir besoin de les cartographier.
Martin Ender
Oh oui, préséance.
Martin Ender
4

APL (17)

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

Explication:

'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

Tester:

      '1',∆[⍋∆←1↓∊⍕¨⍳⎕]
⎕:
      1
1
      '1',∆[⍋∆←1↓∊⍕¨⍳⎕]
⎕:
      10
10123456789
      '1',∆[⍋∆←1↓∊⍕¨⍳⎕]
⎕:
      55
10000011111111111111122222222222222223333333333333333444444444444444455555555555566666777778888899999
marinus
la source
Agréable! Bien mieux que le mien. : DI n'a pas réalisé que cela aplatirait le tableau et vous donnerait une chaîne. C'est bon à savoir.
Alex A.
3

Python 2, 60 octets

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

ClojureScript, 48 octets

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

Comme tous les autres, à peu près. REPL disponible ici .

MattPutnam
la source
3

Ruby, 48 octets

Une fonction anonyme. Fondamentalement, juste Rubyfied certaines des autres réponses ici ..

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

Brachylog , 76 41 octets

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

Prend un nombre en entrée.

Cette solution fonctionne avec les quelques modifications que j'ai apportées au prédicat Findall intégré. f . Apparemment, OP sait utiliser des langages plus anciens que la réponse, je pense donc que tout va bien (les changements que j’ai apportés datent d’il ya longtemps, je me suis motivé à le faire à cause de ce défi).

Explication

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
Fataliser
la source
3

Smalltalk, 76 octets

Comme d'habitude dans Smalltalk, conceptuellement très laconique, mais textuellement très verbeux ...

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

Ajoutez ceci comme méthode de classe pour Stringet appelez comme ceci, par exemple pour 20,String f: 20


la source
3

Utilitaires Bash + GNU, 58

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

Essayez-le en ligne.

Trauma numérique
la source
1
J'avais une approche similaire, mais un traitement différent de la partie "1 au début" (52 octets). Avec le vôtre, vous pouvez vous raser: triez (1 chiffre de long, pas besoin de -n).
Olivier Dulac
3

Bash, 35 à 34 octets

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

Cela s'appuie sur les réponses de @DigitalTrauma et de @OlivierDulac . Essayez-le en ligne avec Ideone .

Comment ça marche

  • seq 2 $1affiche tous les entiers de 2 à celui spécifié sur la ligne de commande.

  • fold -1 enveloppe toutes les lignes de largeur 1, c’est-à-dire qu’elles placent chaque caractère sur sa propre ligne.

    -1 semble être une fonctionnalité non documentée.

  • sort trie les caractères en fonction de leur valeur numérique.

  • printf %d 1`...`​ajoute un 1 à la première ligne et imprime chaque ligne sous la forme d'un entier ( %d), sans séparation.

    Cela tire parti de la curieuse implémentation printf de Bash, qui répète sans cesse la chaîne de formatage, jusqu'à ce que tous les arguments soient consommés.

Dennis
la source
+1, j'aime mieux celui-là que le nôtre :)
Olivier Dulac
3

JavaScript ES6, 49 46 octets

Merci à edc65 pour 2 octets

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

;console.log(F(15))

l4m2
la source
1
J'ai quelque chose de similaire mais 1 octet plus court. Essayez d'utiliser une fonction récursive sans argument, en diminuant simplement le paramètre d'origine x
edc65
2

Julia, 33 octets

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

C'est une fonction lambda qui accepte un entier et retourne une chaîne. Pour l'appeler, assignez-le à une variable.

Nous construisons la plage 2:n, qui sera vide pour n<2, la joindrons en une chaîne, scinderons la chaîne en un tableau de caractères, les trierons, les joindrons en une chaîne et ajouterons 1 au début.

Alex A.
la source
2

APL, 21 octets

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

Il s'agit d'une fonction monadique non nommée qui accepte un entier à droite et retourne une chaîne. Pour l'appeler, assignez-le à une variable.

Explication:

            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)

Essayez-le en ligne

Alex A.
la source
2

Python 2, 60 octets

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

Indexation pour la victoire. :-)


Python 2, 60 octets

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

Juste une alternative.

Zach Gates
la source
2

Voie lactée 1.6.4 , 22 octets (non en compétition)

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

Je devais ajouter un opcode de tri pour ce défi.


Explication

^^                      ` 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
Zach Gates
la source
2

Sérieusement, 10 octets

,u2xεjS'1+

Décharge Hex:

2c753278ee6a5327312b

Essayez-le en ligne

Explication:

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

Outils Bash et GNU, 58 52 octets

echo 1$(seq 2 $1|sed -e 's/./&\n/g'|sort|tr -d \\n)
Olivier Dulac
la source
approche similaire à @ Digital-trauma, mais manière différente d’ajouter le 1, pas besoin de -n car les nombres ont 1 chiffre. (J'ai vu sa réponse après mon premier essai)
Olivier Dulac
2

PowerShell, 61 59 octets

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

Prend l'entrée param($a)et l'utilise ensuite pour indexer dans un tableau avec [$a-eq1]. Si true, nous indexons le deuxième élément et la sortie 1. Sinon, nous concaténons "1"avec le jointableau ed créé par 1) en définissant une nouvelle plage 2..$aelle-même joinédifiée ensemble, 2) en le transformant en tableau de caractères, et 3) en l'envoyant à travers leSort-Object applet de commande, qui sont ensuite tous affichés.

Edit1 - 2 octets enregistrés en déplaçant l' -joinopérateur interne .

AdmBorkBork
la source
2

Gogh , 9 à 7 octets

GJT1-1P

Vous pouvez exécuter ceci en utilisant:

$ ./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 ”
Zach Gates
la source
"Vous pouvez utiliser une langue qui a été créée après ce concours, tant qu'elle n'a pas été conçue pour répondre à ce défi." Je permets à de telles langues d'être compétitives dans mes défis, généralement;)
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ: Oh, génial! Merci de me l'avoir signalé :)
Zach Gates
2

Gelée , 8 octets

RDFṢ1œ|Ḍ

Essayez-le en ligne!

Comment ça marche

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.
Dennis
la source
2

Oracle SQL 11.2, 222 211 octets

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);

Non-golfé

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
       )
Jeto
la source
2

MATL , 17 octets

Utilise la version actuelle (7.0.0) du langage / compilateur.

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

Inspiré par la réponse de FryTheEgggman .

EDIT (29 juillet 2016): Vous pouvez l' essayer en ligne avec quelques modifications pour vous adapter aux changements de langue.

Exemple

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

Explication

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
Luis Mendo
la source
1

05AB1E , 6 octets

Remarque: cette soumission utilise des fonctionnalités postérieures à ce défi et n'est donc pas compétitive.

Code:

Lß?J{?

Explication:

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

Utilise le codage ISO 8859-1

Adnan
la source
Comment cela marche-t-il?
lirtosiast
@ThomasKwa Explanation ajouté
Adnan le
Whoa. C'est fantastique!
Conor O'Brien
1

Mathcad, 86 "octets"

La fonction s (n) utilise une boucle for pour construire "l'entier" de Champernowne en convertissant chaque nombre en forme de chaîne et en les concaténant. La chaîne est ensuite convertie en son vecteur équivalent de codes ASCII et triée. La fonction échange ensuite les zéros non significatifs avec le premier et convertit le vecteur en chaîne.

Pour vérifier la fonction, j'ai placé les scénarios de test dans un vecteur vn, puis appliqué s à vn à l'aide de l'opérateur de vectorisation. Je vérifie ensuite les résultats par rapport aux valeurs du cas de test donné.

enter image description here


Mathcad est une application mathématique basée sur des feuilles de calcul 2D composées de "régions" pouvant chacune être du texte, une expression mathématique, un programme, un tracé ou un composant scripté.

Une instruction mathématique ou de programmation est choisie dans une barre d’outils ou à l’aide d’un raccourci clavier. Pour le golf, une opération ("octet") est considérée comme le nombre d'opérations au clavier nécessaires pour créer un nom ou une expression (par exemple, pour définir la variable a sur 3, nous écririons a: = 3. L'opérateur de définition : = est une simple pression sur la touche ":", tout comme a et 3, donnant un total de 3 "octets". La programmation pour l'opérateur nécessite la saisie de ctl-shft- # (ou un simple clic sur la barre d'outils de programmation). 1 octet.

Stuart Bruff
la source