Los desafíos de Rosetta Stone Code son desafíos en los que debes completar la tarea en tantos idiomas como sea posible.

El reto

Se le darán dos números ny s, en una lista, como entrada. El nserá un número que debe contar hasta. nserá cualquier número del 2 al 10000. sserá el número que omita al contar hasta n. sserá de 1 a n/ 2 (la mitad de n). Si nfue 600, sno podría ser mayor a 300. Debe generar todos los números hasta nsaltar scomenzando con 1. Cada número de salida debe estar en una nueva línea, en la misma línea separada por espacios o en una lista.

El giro

Para este Rosetta Stone Code Challenge, cada fragmento en el que escriba el programa debe tener la misma longitud. es decir: si su programa Python tiene 56 caracteres, entonces su programa Java también debe tener 56 caracteres. Los espacios y comentarios no cuentan como caracteres. Los nombres de variables / funciones no pueden tener más de 10 caracteres. Recuerde, esto también es un código de golf, así que trate de mantener su código corto.

Ejemplo

Entrada

[100, 7]

Salida

1
8
15
22
29
36
43
50
57
64
71
78
85
92
99

Nota: La salida puede estar en una sola línea separada por espacios o formato de lista

Criterio ganador

El ganador se decidirá por esta fórmula:

numberOfLanguages/codeSize

codeSize no es el tamaño total del código, sino el tamaño promedio del código de un fragmento.

El usuario con la puntuación más alta ganará. es decir: una respuesta con 4 idiomas y un tamaño de 31 bytes ganaría una respuesta con 7 idiomas y un tamaño de 80 bytes. Se elegirá un ganador a las 2:00 UTC del 9 de marzo de 2015.

Marcador

^{Todas las puntuaciones se redondean a la milésima más cercana.}

Maltysen - 14 idiomas / 24 caracteres = 0.583 ---- Ganador

mbomb007 - 15 idiomas / 29 caracteres = 0.517

Jakube - 5 idiomas / 11 caracteres = 0.455

Teun Pronk - 4 idiomas / 51 caracteres = 0.078

captncraig - 1 idioma / 56 caracteres = 0.018

14 idiomas - 24 bytes = 0.58333333333

** Facepalm **. Olvidé no contar el espacio en mi respuesta de Python. Entonces estoy en 24 bytes ahora.

Aprendí muchos idiomas nuevos de este desafío, que probablemente usaré en golf. Un sitio que realmente me ayudó a encontrar estos idiomas fue http://www.tutorialspoint.com/codingground.htm . Simplemente no espere que mis programas se ejecuten en él, requiere un formato de programa completo, y simplemente lo usé para aprender sobre los idiomas y usé otros REPL para ejecutarlos.

1. Pyth :

Pyth no tiene una función de rango por paso a diferencia de Python, por lo que usé el rango regular y picado (gracias @Jakube) utilicé el operador mod.

M%Hr+Z+Z+Z+Z+Z+Z+Z+Z1+1G

Define una función g (hasta, paso)

M          Define g(G, H)
 %H        Every H elements
  r1+1G      Range 1->G+1

2. Golfscript:

Este es mi primer programa de golfscript. Probablemente no sea la mejor manera de hacerlo.

000000000000000;\),1>\%p

\         swap
 )        increment
  ,       range
   1>     all but first element
   \      swap
    %     take every top of stack elements
     p    print array

3. Bash Utils:

Utiliza el comando seq que tiene INCREMENT param.

seq 00000000000000001 $2 $1

4,5. Python, sabio :

Código autoexplicativo.

lambda a,b:range(1,a+1,b)

Sage es un lenguaje basado en Python usado para cosas de matemáticas.

6. Mathematica:

De nuevo, se explica por sí mismo.

r[a_,b_]:=Range[001,a,b]

7. Matlab:

Utiliza la notación de rango de Matlab y define una función anónima.

@(a,b)00000000000001:b:a

8. Livescript:

Al igual que Coffeescript, es un derivado de JS. Tiene una sintaxis de rango genial. Notación de flecha de nuevo.

r=((((a,b)->[1 to a by b])))

9. Erlang:

Erlang aprendido solo por esto. Bastante autoexplicativo, define la función r.

r(a,b)->lists:seq(1,a,b)

10. F #:

Como obvio, las definiciones de funciones de F # son como variables.

let r a b=seq{000001..b..a}

11. Haskell:

La notación de rango de Haskell le da los dos primeros en el rango para el incremento, y no un incremento explícito.

r a b=[00000000001,a+1..b]

12. R:

Lenguaje muy interesante, incluso si las definiciones de funciones son un poco detalladas.

function(a,b)seq(01,a,b)

13. Julia:

Lenguaje impresionante , se utilizará para jugar al golf en el futuro.

r(a,b)=[00000000001:b:a]

14. CJam:

Como mi vieja respuesta de golfscript, excepto con el análisis y el relleno de entrada.

0000000000000;q~\),1>\%p

23 idiomas, 15 caracteres = 1.5333333

+---------------+----------------------+----------------+
|    Language   |         Code         |      Kind      |
+---------------+----------------------+----------------+
|          gs2  |  B/4[RRRRRRRRRRR     |  (stack)       |
|         Pyth  |  M%+Z+Z+Z+Z+ZHSG     |  (definition)  |
|   GolfScript  |  \),000000001>%p     |  (stack)       |
|         CJam  |  \),000000001>%p     |  (stack)       |
|          zsh  |  seq 00000001 $2 $1  |  (script)      |
|         Bash  |  seq 00000001 $2 $1  |  (script)      |
|   FlogScript  |  \),0000001>\%Pa     |  (stack)       |
|          APL  |  {00001+⍵×⍳⌈⍺÷⍵}     |  (lambda)      |
|      Mathics  |  00001~Range~##&     |  (lambda)      |
|  Mathematica  |  00001~Range~##&     |  (lambda)      |
|            J  |  ({.\00001+i.)~-     |  (lambda)      |
|       Matlab  |  @(a,b)00001:b:a     |  (lambda)      |
|       Octave  |  @(a,b)00001:b:a     |  (lambda)      |
|    Burlesque  |  jrojcoq-]m[m]uN     |  (stack)       |
|            K  |  {0001+&~(!x)!y}     |  (lambda)      |
|          Pip  |  {_%b=001FI,++a}     |  (lambda)      |
|      Haskell  |  ff a b=[1,b+1..a]   |  (definition)  |
|        Clean  |  ff a b=[1,b+1..a]   |  (definition)  |
|        Curry  |  ff a b=[1,b+1..a]   |  (definition)  |
|        Frege  |  ff a b=[1,b+1..a]   |  (definition)  |
|        Julia  |  ff(a,b)=[1:b:a]     |  (definition)  |
|       Scotch  |  f(a,b)=[1..a,b]     |  (definition)  |
|        Perl6  |  {1,$^b+1...$^a}     |  (lambda)      |
+---------------+----------------------+----------------+

5 idiomas 11 caracteres = 0.4545

Tomó este desafío como una oportunidad para ver algunos lenguajes nuevos (CJam, Burlesque, zsh, gs2). Primera vez que trabajo con estos idiomas.

El método detrás de la creación de la salida es diferente en casi cada idioma. Solo el método CJam y gs2 son idénticos. Los 4 métodos son, crear un rango [1, 100] y cortarlo con módulo (CJam y gs2), crear el rango [1, ..., 100] y filtrar elementos que son 1 mod 7 (Pyth), creando el rango [1, ..., 100], divídalo en fragmentos de len 7 y use el primer elemento de cada fragmento (Burlesque), y cree la secuencia directamente (zsh).

Traté de diseñar cada programa de tal manera que parezca perfecto para alguien que no está familiarizado con el idioma.

edición 1: agregado burlesco, 2 idiomas anteriores con 10 caracteres = 0.2

edit 2: gs2 agregado, 3 idiomas anteriores con 11 caracteres = 0.2727

edit 3: zsh agregado, 4 idiomas anteriores con 11 caracteres = 0.3636

CJam

q~\1+,0-\%p

Pruébalo línea con la entrada 100 7.

q~           push the evaluated input (100 7)
  \          swap (7 100)
   1         push 1 (7 100 1)
    +        add last to elements (7 101)
     ,        create the range (7, [0, 1, ..., 100])
      0       push 0 (7, [0, 1, ..., 100], 0)
       -      delete 0 from the range (7, [1, 2, ..., 100])
        \     swap ([1, 2, ..., 100], 7)
         %    use every 7th entry ([1, 8, ..., 99])
          p   print pretty

Burlesco

jrojcoq-]m[

Además de zsh, este es el único programa de golf. Burlesque es bastante impresionante, tiene una amplia gama de funciones diferentes, como ro. Lamentablemente, no hay nada como el [::a]operador de corte Python .

No hay un intérprete en línea, pero puede obtener Burlesque aquí. . Como Burlesque no admite funciones o IO, primero debe colocar los valores en la pila, como100 7 jrojcoq-]m[

j            Swap (7 100)
 ro          Range (7 {1 2 ...  100})
   j         Swap ({1 2 ... 100} 7)
    co       ChunksOf ({{1 2 ..  7} {8 ... 14} ... {99 100}})
      q      Create Block ({{1 2 ..  7} {8 ... 14} ... {99 100}} {}) 
       -]    head (first element) ({{1 2 ..  7} {8 ... 14} ... {99 100}} {-]}) 
         m[  map the chunks to the head-block

gs2

read-nums dup head inc range tail swap reverse head mod unlines

Sí, esto es solo 11 caracteres. En gs2 cada byte tiene un significado diferente. Pero debido a que escribir en bytes es bastante difícil y no es divertido, también puede escribir en mnemotécnicos, que puede compilar en el código gs2 real. El código gs2, que se ejecuta es

W@!'."B !4+

o como volcado hexadecimal:

57 40 21 27 2e 22 42 20 21 34 2b

Dato curioso: no escribí en mnemotecnia, sino directamente los números del volcado hexadecimal.

Puede probarlo descargando el compilador . Compile el archivo mnemonics con python gs2c.py < mnemonics.txt > compiledo simplemente cópielo W@!'."B !4+en un archivo llamado compiledy luego ejecútelo conecho 100 7 | python gs2.py compiled .

La mnemotecnia es bastante autoexplicable, pero esto es lo que está sucediendo en la pila.

57 40 21 27 2e 22 42 20 21 34 2b 
57                                 read-nums ([100 7])
   40                              dup ([100 7] [100 7])
      21                           head ([100 7] 100)
         27                        inc ([100 7] 101)
            2e                     range ([100 7] [0 1 ... 100])
               22                  tail ([100 7] [1 2 ... 100])
                  42               swap ([1 2 ... 100] [100 7])
                     20            reverse ([1 2 ... 100] [7 100])
                        21         head ([1 2 ... 100] 7)
                           34      mod ([1 8 ... 99])
                              2b   unlines ('1\n8\n...\n99')
                                   everything on the stack gets printed

Por cierto, son posibles 8 bytes, quizás incluso menos.

editar: bifurqué gs2, manipulé ligeramente un comando e hice una solicitud de extracción, que ya está fusionada. Entonces, la tarea se puede hacer con 6 bytes: lo read-nums extract-array swap range1 mod unlinesque se traduce en 57 0e 42 2f 34 2b, que es incluso mejor que la pyth óptima.

zsh

f() seq 1 $2 $1

Esto define una función f, que crea una secuencia. Para usarlo en Windows, instalé el shell babun , donde simplemente puede escribir estos comandos. Simplemente escriba f() seq 1 $2 $1y en la siguiente línea f 100 7.

Primero intenté escribir esto en Bash, pero allí tienes que escribir ()alrededor del bloque de código, como f() ( seq 1 $2 $1 ). Entonces cambié a zsh en su lugar.

Pyth

fq1%TeQUhhQ

Esto realmente duele, ya que, por supuesto, veo el obvio golf de 7 bytes. Puede probarlo en línea con la entrada 100, 7.

                 Q = input()
       UhhQ      the range [0, 1, ..., Q[0]]
f                filtered (only use those elements T, which satisfy the equation
 q1%TeQ             1 == T % Q[1]

15 idiomas, 29 caracteres = (15/29) ≈ 0.517

He arreglado todo mi código hasta ahora. Ahora estoy buscando otros idiomas.

1. Python (24 de golf)

f=lambda n,s:range(0001,n+1,s)

2.> <> (Pescado) - (19 + caracteres basura)

Este programa asume que el número y el tamaño del paso estaban en la pila de antemano, empujados en ese orden. Usos aopara imprimir nuevas líneas entre números.

1           v
$:@+:{:}(?!;>:nao
~~~~~~~~~~

Explicación (código, pila después de la ejecución del código anterior, comentarios):

1               1 s n           start n0=1. stack is (top)1 s n(bottom)
(skip to print code - last line of explanation, then come back)
 $:@            s 1 s n         swap, duplicate, rotate top 3 (this all is OVER in Forth)
   +:           n1 n1 s n       add step to x and dup
    {:}         n n1 n1 s n     compare to n
       (        n1>n n1 s n     if !(n1 > n), JUMP: dup and print (continue)
        ?!;     n1 s n          else exit
          :nao  n1 s n          dup, print n1, newline, loop around

3. APL (19 de golf)

fffffffff←{(⌈⍵÷⍺)↑1+⍺∘.×(⍳⍵)}

Golfed . Pega aquí: http://ngn.github.io/apl/web/

f←{(⌈⍵÷⍺)↑1+⍺∘.×⍳⍵}

Llamar así: 7 f 100. Esto crea una matriz de 1 a n, multiplica cada elemento por s, agrega uno a cada elemento y luego toma los primeros elementos ceil (n / s).

4-7. Haskell , Clean , Curry , Frege (14 golf - los espacios no cuentan)

Este programa es válido en Haskell, Clean, Curry y Frege.

ffffffffff nnnn s=[1,s+1..nnnn]

Golfizado Ejecutar aquí: https://ideone.com/Ii0pgP

f n s=[1,s+1..n]

8. Scotch (15 de golf)

fffffffff(nnnn,s)=[1..nnnn,s]

9. Jaskell (24 jugadores de golf): construido según la documentación.

Filtre la lista donde el resto del módulo s es 1.

ffffff n s=filter(.%s==1)[1..n]

10. CoffeeScript (25 golf) Corre aquí

fffff=(n,s)->x for x in[1..n]by s

11. R (25 golfed) Corre aquí: http://www.r-fiddle.org/#/fiddle?id=k3vRnCOW&version=2

fffff=function(n,s)seq(1,n,s)

12. Cobra (26 golfistas)

def ffff(n,s)
    for i in 1:n:s
        print i

13. S-Lang (28 golfizados)

define ff(n,s){return [1:n:s];}

14. Boo (29)

No estoy seguro si la función de rango puede tomar 3 parámetros ...

def f(n,s):return range(n)[::s]

15. Funge-98 (29, ¿alguna ayuda para jugar al golf?)

Tan cerca como pude llegar a mi> <> programa. Como no hay instrucciones de pila "rotar", tuve que usar "poner" y "obtener" en su lugar. Befunge realmente necesita algunas instrucciones de rotación / cambio de pila, o incluso una instrucción "sobre".

22p1v
    >:.a,\:33p\33g+:22g\`!j@

Explicación:

        n s
22p     s           (store n at 2,2)
1       1 s         (push 1)
(v and > are direction changes, so the above only happens once)
\:      s s 1       (swap, dup)
33p     s 1         (store s at 3,3)
\33g    s 1 s       (get s)
+:      n1 n1 s     (add, dup)
22g     n n1 n1 s   (get n)
\`!     !(n1>n) n1 s    (swap, >, not)
j@      n1 s        (conditional exit)
:.a,    n1 s        (print n1, newline)

NO SE UTILIZA EN EL MOMENTO, DEMASIADO LARGO : mi puntaje mejora al no incluirlos.

Ruby (35) Corre aquí: http://ideone.com/yFZELR

def f(n,s)
    (1..n).select{|x|x%s==1}
end

PowerShell (38)

function f($n,$s){(1..$n|?{$_%$s-eq 1})}

Perl (39) Ejecutar aquí: https://ideone.com/HGoleN

sub f{join(" ",grep $_%@_[1]==1, 1..@_[0])}

4 idiomas 51 caracteres = (4/51) = 0,0784313725490196

No tengo idea de cuántos números después de la coma quieres, así que lo dejaré así.
Todos los fragmentos tienen 51 caracteres cuando elimina todo el espacio en blanco.
Trabajando en código más y más corto pero es un comienzo

Iniciar sesión

Respuesta inicial
Enviado Python (3.4), Lua (5.1) y Javascript.
Puntuación: 3/51 = 0,0588235294117647

Actualización 1 Puntaje
rubí agregado
: 4/51 = 0,0784313725490196.

Python 3.4

def f(NUMB,ST):
    CNT=1
    while CNT<=NUMB:
        print(CNT)
        CNT+=ST

Lua 5.1

function f(num,st)
    for cn=1,num,st do
        print(cn);
    end;
end;

Javascript

function f(n,s){
  for(i=1;i<=n;i+=s){
    console.log(i);
  }
}

Rubí

def faa(numb,st) 
  for i in 1..numb 
    if i%st==1 
      puts i 
    end 
  end 
end

1 idioma - 56 caracteres = 0.01785714285

piet (2x28) -