Os Desafios do Código de Pedra da Rosetta são desafios em que você deve concluir a tarefa no maior número de idiomas possível.

O desafio

Você receberá dois números ne s, em uma lista como entrada. O nserá um número que você tem que contar até. nserá qualquer número de 2 a 10000. sserá o número que você pular ao contar até n. sserá de 1 a n/ 2 (metade n). Se nfosse 600, snão poderia ser maior que 300. Você deve gerar todos os números até npular, siniciando com 1. Cada número de saída deve estar em uma nova linha, na mesma linha separada por espaços ou em uma lista.

The Twist

Para este Desafio de código de pedra da Rosetta, cada trecho em que você escreve o programa deve ter o mesmo comprimento. ou seja: se o seu programa Python tiver 56 caracteres, seu programa Java também deverá ter 56 caracteres. Espaços e comentários não contam como caracteres. Os nomes de variáveis ​​/ funções não podem ter mais que 10 caracteres. Lembre-se, isso também é código de golfe, portanto, tente manter seu código curto.

Exemplo

Entrada

[100, 7]

Resultado

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

Nota: A saída pode estar em uma única linha separada por espaços ou formato de lista

Critério vencedor

O vencedor será decidido por esta fórmula:

numberOfLanguages/codeSize

codeSize não é o tamanho total do código, mas o tamanho médio do código de um snippet.

O usuário com a pontuação mais alta vencerá. ou seja: uma resposta com 4 idiomas e um tamanho de 31 bytes conquistaria uma resposta com 7 idiomas e um tamanho de 80 bytes. Um vencedor será escolhido às 2:00 UTC de 9 de março de 2015.

Placar

^{Todas as pontuações são arredondadas para o milésimo mais próximo}

Maltysen - 14 idiomas / 24 caracteres = 0,583 ---- Vencedor

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 **. Eu esqueci de não contar o espaço na minha resposta em Python. Então, eu tenho 24 bytes agora.

Aprendi sobre muitas novas línguas com este desafio, que provavelmente usarei nos campos de golfe. Um site que realmente me ajudou a encontrar esses idiomas foi http://www.tutorialspoint.com/codingground.htm . Só não espere que meus programas sejam executados nele, ele requer um formato de programa completo e eu apenas o usei para aprender sobre os idiomas e usei outros REPLs para executá-los.

1. Pitão :

Não Pyth não tem uma gama de função degrau ao contrário python, então eu usei gama regular e picadas (graças @Jakube) usado operador mod nele.

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

Define uma função g (até, etapa)

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

2. Golfscript:

Este é o meu primeiro programa de golfe. Provavelmente não é a melhor maneira de fazê-lo.

000000000000000;\),1>\%p

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

3. Bash Utils:

Usa o comando seq que possui os parâmetros INCREMENT.

seq 00000000000000001 $2 $1

4,5 Python, Sábio :

Código auto-explicativo.

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

Sage é uma linguagem baseada em Python usada para coisas matemáticas.

6. Mathematica:

Mais uma vez, auto-explicativo.

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

7. Matlab:

Usa a notação de intervalo do Matlab e define uma função anônima.

@(a,b)00000000000001:b:a

8. Livescript:

Como o Coffeescript, é um derivado do JS. Possui sintaxe de intervalo legal. Notação de seta novamente.

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

9. Erlang:

Erlang aprendido apenas por isso. Bastante auto-explicativo, define a função r.

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

10. F #:

Obviamente, as definições de função do F # são como variáveis.

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

11. Haskell:

A notação de intervalo de Haskell fornece os dois primeiros no intervalo para o incremento, e não um incremento explícito.

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

12. R:

Linguagem muito legal, mesmo que as definições de função sejam um pouco detalhadas.

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

13. Julia:

Linguagem impressionante , estará usando para jogar golfe no futuro.

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

14. CJam:

Como a minha antiga resposta do GolfScript, exceto com análise e preenchimento 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

Aceitou esse desafio como uma oportunidade de verificar alguns novos idiomas (CJam, Burlesque, zsh, gs2). Primeira vez que trabalhei com esses idiomas.

O método por trás da criação da saída é diferente em quase todos os idiomas. Somente o método CJam e o gs2 são idênticos. Os 4 métodos são: criar um intervalo [1, 100] e dividi-lo com módulo (CJam e gs2), criar o intervalo [1, ..., 100] e filtrar elementos que sejam 1 mod 7 (Pyth), criar o intervalo [1, ..., 100], divida-o em pedaços de len 7 e use o primeiro elemento de cada pedaço (burlesco) e crie a sequência diretamente (zsh).

Tentei projetar cada programa de tal maneira que parecesse um jogo para alguém que não estivesse familiarizado com o idioma.

edit 1: adicionado burlesco, 2 idiomas anteriores com 10 caracteres = 0,2

editar 2: adicionado gs2, 3 idiomas anteriores com 11 caracteres = 0,2727

edit 3: zsh adicionado, 4 idiomas anteriores com 11 caracteres = 0,3636

CJam

q~\1+,0-\%p

Teste online com a 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

Burlesque

jrojcoq-]m[

Ao lado do zsh, este é o único programa de golfe. Burlesco é bastante impressionante, tem uma gama muito grande de funções diferentes, como ro. Infelizmente, não há nada como o [::a]operador de fatiador Python .

Não há intérprete on-line, mas você pode obter o Burlesque aqui . Como o Burlesque não suporta funções ou IO, você deve colocar os valores na pilha primeiro, 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

Sim, isso é apenas 11 caracteres. No gs2, cada byte tem um significado diferente. Mas como escrever em bytes é bastante difícil e não é divertido, você também pode escrever em mnemônicos, que pode compilar com o código gs2 real. O código gs2, que é executado é

W@!'."B !4+

ou como hex-dump:

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

Curiosidade: não escrevi em mnemônicos, mas diretamente nos números do hex-dump.

Você pode testá-lo baixando o compilador . Compile o arquivo mnemônico python gs2c.py < mnemonics.txt > compiledou simplesmente copie W@!'."B !4+para um arquivo chamado compilede execute-o com echo 100 7 | python gs2.py compiled.

A mnemônica é bastante autoexplicável, mas aqui está o que está acontecendo na pilha.

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

Entre, 8 bytes são possíveis, talvez até menos.

edit: bifurquei o gs2, manipulei levemente um comando e fiz uma solicitação pull, que já está mesclada. Portanto, agora a tarefa pode ser executada com 6 bytes :, read-nums extract-array swap range1 mod unlinesque se traduz em 57 0e 42 2f 34 2b, o que é ainda melhor que o pyth ideal.

zsh

f() seq 1 $2 $1

Isso define uma função fque cria a sequência. Para usá-lo no Windows, instalei o babun shell, onde você pode simplesmente digitar esses comandos. Basta escrever f() seq 1 $2 $1e na próxima linha f 100 7.

Primeiro eu tentei escrever isso no Bash, mas aí você tem que escrever em ()torno do bloco de código, como f() ( seq 1 $2 $1 ). Então, mudei para o zsh.

Pyth

fq1%TeQUhhQ

Isso realmente dói, pois é claro que vejo o óbvio golfe de 7 bytes. Você pode testá-lo online com a 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

Corrigi todo o meu código até agora. Agora estou pesquisando outros idiomas.

1. Python (24 jogadores de golfe)

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

2.> <> (Peixe) - (19 + caracteres indesejados)

Este programa pressupõe que o número e o tamanho da etapa estejam na pilha previamente, pressionados nessa ordem. Usa aopara imprimir novas linhas entre números.

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

Explicação (código, pilha após a execução do código anterior, comentários):

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 jogadores de golfe)

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

Golfed . Cole aqui: http://ngn.github.io/apl/web/

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

Chamada assim: 7 f 100. Isso cria uma matriz de 1 para n, multiplica cada elemento por s, adiciona uma a cada elemento e, em seguida, pega os primeiros elementos de teto (n / s).

4-7. Haskell , Limpo , Caril , Frege (14 campos de golfe - os espaços não contam)

Este programa é válido em Haskell, Clean, Curry e Frege.

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

Golfed. Execute aqui: https://ideone.com/Ii0pgP

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

8. Scotch (15 jogadores de golfe)

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

9. Jaskell (24 jogadores de golfe ) - Construído com base na documentação.

Filtre a lista onde o restante do módulo é 1.

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

10. CoffeeScript (25 jogadores) Corra aqui

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

11. R (25 jogadores) Corra aqui: http://www.r-fiddle.org/#/fiddle?id=k3vRnCOW&version=2

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

12. Cobra (26 jogando golfe)

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

13. S-Lang (28 jogadores de golfe)

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

14. Boo (29)

Não tenho certeza se a função de intervalo pode levar três parâmetros ...

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

15. Funge-98 (29, alguma ajuda no golfe?)

O mais perto que pude chegar ao meu programa> <>. Como não há instrução "rotate" na pilha, tive que usar "put" e "get". O Befunge realmente precisa de algumas instruções de rotação / deslocamento de pilha, ou mesmo uma instrução "over".

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

Explicação:

        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)

NÃO USAR NO MOMENTO, MUITO LONGO - Minha pontuação é aprimorada por não incluí-las.

Rubi (35) Run aqui: 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) Execute aqui: https://ideone.com/HGoleN

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

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

Não faço ideia de quantos números depois de vírgula você deseja, então deixarei assim.
Todos os snippets têm 51 caracteres quando você remove todo o espaço em branco.
Trabalhando em códigos cada vez menores, mas é um começo.

Registro

Resposta inicial
Enviado Python (3.4), Lua (5.1) e Javascript.
Pontuação: 3/51 = 0,0588235294117647

Atualização 1 : Pontuação
Ruby adicionada
: 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);
  }
}

Rubi

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