El número de Rien

38

La constante de Champernowne es un número que se construye concatenando los primeros nnúmeros, con ntendencia al infinito. Se parece a esto:

0.123456789101112131415161718192021222324252627282930...

Ahora, te describiré el número de Rien . Puede considerarse como una minimización de la constante de Champernowne como un número entero. Me referiré al número de Rien con los primeros ndígitos como Ri ( n ). Así es como se formula:

  1. Los primeros nnúmeros naturales (la secuencia {1,2,3, ...}) se concatenan.
  2. Este resultado se ordena de acuerdo con el valor del dígito. Así 1..12se vería así 011111223456789.
  3. Desde la Rien número no puede tener ceros a la izquierda, que mover toda 0s para que sean significativos, mientras que mantener el número reducido al mínimo, lo que resulta en, por ejemplo, 101111223456789. Este es Ri ( n ), en este caso, Ri (12).

Aquí hay algunos resultados para Ri ( n ):

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

Objetivo Dado un número 1 ≤ n<10000 como entrada (a través de argumentos, STDIN o hardcoding si su idioma no admite entrada convencional), salida / retorno Ri ( n).

Este es un , por lo que gana el código más corto en bytes. Puede usar un idioma que se haya creado después de este concurso, siempre que no haya sido creado para responder a este desafío. (Por supuesto, puede usarlo, si proporciona una solución interesante, pero marque su respuesta como no competitiva).

Implementación de referencia

Probé esto en IE, por lo que realmente no debería haber un problema. Si no es un problema, hay una solución fácil: conseguir un navegador cuerdo.

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


Tabla de clasificación

El Fragmento de pila al final de esta publicación genera el catálogo a partir de las respuestas a) como una lista de la solución más corta por idioma yb) como una tabla de clasificación general.

Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

## Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento:

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

Conor O'Brien
fuente
22
Siempre pensé que 0es el número de Rien .
falla
No estoy seguro de si me falta algo, pero podemos mover uno de los 1s delante de los 0s, ¿sí?
FryAmTheEggman
@FryAmTheEggman Estás en lo correcto.
Conor O'Brien
@ MartinBüttner \ o / lo encontraste.
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ No, ese era diferente. Ese solo permitía permutaciones de los números enteros, no de sus dígitos individuales.
Martin Ender

Respuestas:

12

Pyth, 8

+1SjktSQ

Hace una lista, [1, .. , input]luego elimina la primera, une y ordena, y antepone un 1.

Banco de pruebas

FryAmTheEggman
fuente
13

Perl, 44 42 41 33 31 bytes

Yaaay, primera publicación!

Gracias a primo por el ahorro de 2 bytes.

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

Como lo hicieron otros, eliminar 1 y anteponerlo manualmente hace el trabajo.

Pruébalo en línea

Paul Picard
fuente
2
Bienvenido a PPCG, y felicidades por tu primera publicación (aunque parece extraño que te dé la bienvenida, ya que te uniste antes que yo ...). Dos cosas: cuento 43 bytes ... segundo, su enlace "Pruébelo en línea" parece apuntar a una revisión anterior / diferente de su código. Copiar y pegar manualmente su código en Ideone funciona, pero no su enlace.
AdmBorkBork
Gracias por tu comentario ! Usé TextWrangler para el recuento de bytes, supongo que fui 1 demasiado lejos ... (además no se necesitaba un espacio, por lo que reduce todo el recuento de bytes a 42). La Ideone debería ser reparada ahora.
Paul Picard
Oh, no sabía sobre eso. También funciona en mi Perl en mi Mac (5.18) ¡Gracias!
Paul Picard
2
Ahorró dos bytes al deshacerse de la división / unión:print 1,sort"@{[2..<>]}"=~/\d/g
primo
11

Japt, 14 12 bytes

1+2o°U ¬¬n ¬

Pruébalo en línea!

Cómo funciona

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
ETHproducciones
fuente
44
o_o lo jugaste en el período de gracia de 5 minutos? El arma más rápida del oeste
Conor O'Brien el
@ CᴏɴᴏʀO'Bʀɪᴇɴ Supongo que no quieres publicar nuevos códigos de golf después de eso: D
Pierre Arlaud
9

Retina , 78 bytes

Es hora de mostrar algunas características nuevas de Retina (todavía no es muy competitivo, pero antes de hoy probablemente habría estado más cerca de los 300 bytes).

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

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

Pruébalo en línea.

Explicación

Si bien es posible convertir entre decimal y unario bastante convenientemente ahora, esto todavía es bastante largo porque tengo que convertir varias veces hacia adelante y hacia atrás porque algunas operaciones son más factibles en decimal que en unario y viceversa.

.+
$0$*1

Comencemos convirtiendo la entrada a unario. Esto funciona haciendo coincidir la entrada y luego usando $*1las repeticiones 1tantas veces (esta característica de repetición es nueva a partir de hoy).

\B
 $`

A continuación, generamos un rango de 1a Nen unario. Le expliqué por qué esto funciona en mi respuesta de FizzBuzz .

(1)+
$#1

Convertimos cada número en el rango de nuevo a decimal para que podamos trabajar con los dígitos decimales. Esto se realiza haciendo coincidir cada uno de los números unarios de modo que cada uno 1genere una captura separada. Luego reemplazamos eso con el número de capturas del grupo uno, usando la nueva sintaxis de conteo de captura $#1.

^1| 

Esto elimina los 1espacios iniciales y todos los espacios de la cadena, por lo que solo nos quedan los dígitos (excepto un solo 1).

.
 1$0$*1

Convertimos de nuevo a unario y lo agregamos 1a cada dígito (para asegurar que incluso 0sea ​​un no vacío). También insertamos un espacio delante de cada dígito para asegurarnos de que estén separados.

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

Emparejamos repetidamente un número pequeño precedido por un número mayor y los intercambiamos. Eso es burbuja en Retina. :)

 1(1)*
$#1

Aaa y de vuelta al decimal.

^
1

Finalmente, insertamos un solo 1en el frente para dar cuenta del que hemos eliminado anteriormente.

Martin Ender
fuente
1
¿De qué nuevas características hablas?
Conor O'Brien el
1
@ CᴏɴᴏʀO'Bʀɪᴇɴ Agregaré una explicación más tarde. Este usa una nueva sintaxis de sustitución para contar capturas y repetir caracteres que se pueden usar para una conversión decimal / unaria razonablemente corta. Aquí está el registro de cambios completo: github.com/mbuettner/retina/blob/master/CHANGELOG.md
Martin Ender
@ MartinBüttner bien. ¿Significa esto que Retina ya no puede reclamar esta exención ?
Trauma digital el
@DigitalTrauma I think it's still the most natural form of input. Also I never understood how that kind of language-ism ever got so much support on this site.
Martin Ender
6

Haskell, 44 bytes

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

Unfortunately sort is in Data.List, that's 17 bytes!

nimi
fuente
6

JavaScript (ES6), 65 62 54 52 bytes

Saved 3 bytes thanks to edc65

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

Builds a string of all numbers from 2 to x, then splits, sorts, joins, and adds a 1 to the beginning. This may still be golfable; suggestions welcome!

ETHproductions
fuente
I don't have ES6 on hand, but can't you just use (new) Array(x-1).map((_,y)=>y+2)?
Conor O'Brien
@CᴏɴᴏʀO'Bʀɪᴇɴ map skip empty array elements, so you should use Array(n).fill().map(... (see ES6 tips)
edc65
Too late to post mine, but a hint for you: n=>1+[...[...Array(n-1)].map(_=>++n,n=1).join``].sort().join`` (1 byte shorter, it's the split)
edc65
@edc65 and Cᴏɴᴏʀ O'Bʀɪᴇɴ Thanks for the tips! I wondered why using .split() felt so odd...
ETHproductions
@edc65 Huh, is my solution the same length as yours: n=>1+[...[...Array(n+1).keys()].slice(2).join``].sort().join``
Neil
5

Mathematica, 52 bytes

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

Once again, string processing happened...

LegionMammal978
fuente
I think IntegerDigits threads over lists so you don't need map it.
Martin Ender
Oh right, precedence.
Martin Ender
4

APL (17)

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

Explanation:

'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
marinus
fuente
Nice! Much better than mine. :D I didn't realize that would flatten the array and give you a string. That's good to know.
Alex A.
3

Python 2, 60 bytes

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

ClojureScript, 48 bytes

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

Same as all of the others, pretty much. REPL available here.

MattPutnam
fuente
3

Ruby, 48 bytes

An anonymous function. Basically just Rubyfied some of the other answers here..

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

Brachylog, 76 41 bytes

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

Takes a number as input.

This solution works with the few changes I made to the built-in Findall predicate f. OP is apparently OK with using languages older than the answer so I think this is fine (the changes I made were intented a long time ago, I just motivated myself to do it because of this challenge).

Explanation

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
Fatalize
fuente
3

Smalltalk, 76 bytes

As usual in Smalltalk, conceptually very terse, but textually very verbose...

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

Add this as a class method for String and call like this, e.g. for 20, String f: 20


fuente
3

Bash + GNU utilities, 58

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

Try it online.

Digital Trauma
fuente
1
I had a similar approach, but a different handling of the "1 at beginning" part (52 bytes). With yours, you can shave off : sort (1 digit long, no need for -n).
Olivier Dulac
3

Bash, 35 34 bytes

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

This builds on the answers of @DigitalTrauma and @OlivierDulac. Try it online with Ideone.

How it works

  • seq 2 $1 prints all integers from 2 to the one specified on the command line.

  • fold -1 wraps all lines with width 1, i.e., places each character on its own line.

    -1 seems to be an undocumented feature.

  • sort sorts the characters by their numeric value.

  • printf %d 1`...`​ prepends a 1 to the first line and prints each line as an integer (%d), with no separation.

    This takes advantage of Bash's curious printf implementation, which repeats the format string over and over, until all arguments are consumed.

Dennis
fuente
+1, I like that one better than ours :)
Olivier Dulac
3

JavaScript ES6, 49 46 Bytes

Thanks to edc65 for 2 bytes

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

;console.log(F(15))

l4m2
fuente
1
I got something similar but 1 byte shorter. Try using a recursive function with no argument, just decreasing the original parameter x
edc65
2

Julia, 33 bytes

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

This is a lambda function that accepts an integer and returns a string. To call it, assign it to a variable.

We construct the range 2:n, which will be empty for n < 2, join it into a string, splat the string into an array of characters, sort them, join it into a string, and prepend 1.

Alex A.
fuente
2

APL, 21 bytes

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

This is an unnamed monadic function that accepts an integer on the right and returns a string. To call it, assign it to a variable.

Explanation:

            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)

Try it online

Alex A.
fuente
2

Python 2, 60 bytes

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

Indexing for the win. :-)


Python 2, 60 bytes

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

Just an alternative.

Zach Gates
fuente
2

Milky Way 1.6.4, 22 bytes (not competing)

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

I had to add a sorting opcode for this challenge.


Explanation

^^                      ` 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
fuente
2

Seriously, 10 bytes

,u2xεjS'1+

Hex Dump:

2c753278ee6a5327312b

Try It Online

Explanation:

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

Bash and GNU tools, 58 52 bytes

echo 1$(seq 2 $1|sed -e 's/./&\n/g'|sort|tr -d \\n)
Olivier Dulac
fuente
similar approach than @Digital-trauma , but different way to add the 1, and no need for -n as numbers are 1 digit long. (I saw his answer after I did my first try)
Olivier Dulac
2

PowerShell, 61 59 bytes

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

Takes input param($a) and then uses it to index into an array with [$a-eq1]. If true, we index the second element and output 1. Otherwise, we concatenate "1" with the joined array created by 1) defining a new range 2..$a that has been itself joined together, 2) casting that as a char-array, and 3) sending it through the Sort-Object cmdlet, all of which is then output.

Edit1 -- Saved 2 bytes by moving the inner -join operator.

AdmBorkBork
fuente
2

Gogh, 9 7 bytes

GJT1-1P

You can run this using:

$ ./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
fuente
"You may use a language that was made after this contest, as long as it was not made for answering this challenge." I allow such languages to be competitive in my challenges, usually ;)
Conor O'Brien
@CᴏɴᴏʀO'Bʀɪᴇɴ: Oh, awesome! Thanks for pointing that out :)
Zach Gates
2

Jelly, 8 bytes

RDFṢ1œ|Ḍ

Try it online!

How it works

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
fuente
2

Oracle SQL 11.2, 222 211 bytes

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
       )
Jeto
fuente
2

MATL, 17 bytes

Uses current version (7.0.0) of language/compiler.

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

Inspired by FryTheEgggman's answer.

EDIT (July 29, 2016): You can try it online with some modifications to conform to changes in the language.

Example

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

Explanation

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
fuente
1

05AB1E, 6 bytes

Note: This submission uses features that postdate this challenge and is therefore not competitive

Code:

Lß?J{?

Explanation:

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

Uses ISO 8859-1 encoding

Adnan
fuente
How does this work?
lirtosiast
@ThomasKwa Explanation added
Adnan
Whoa. This is fantastic!
Conor O'Brien
1

Mathcad, 86 "bytes"

The function s(n) uses a for loop to build up the Champernowne "integer" by converting each number to its string form and concatenating them together. The string is then converted to its equivalent vector of ASCII codes and sorted. The function then swaps any leading zeros with the first one, finally converting the vector back to a string.

To check the function, I put the test cases into a vector vn, then applied s to vn using the vectorize operator. I then check the results against the given test case values.

enter image description here


Mathcad is mathematical application based on 2D worksheets comprised of "regions" each of which can be text, a mathematical expression, program, plot or scripted component.

A mathematical or programming instruction is picked from a palette toolbar or entered using a keyboard shortcut. For golfing purposes, an operation ("byte") is taken to be the number of keyboard operations necessary to create a name or expression (for example, to set the variable a to 3, we would write a:=3. The definition operator := is a single keypress ":", as are a and 3 giving a total of 3 "bytes". The programming for operator requires typing ctl-shft-# (or a single click on the programming toolbar) so again is equivalent to 1 byte.

Stuart Bruff
fuente