Desafio de golfe do código de pedra Rosetta: imprima determinados números; todos os snippets devem ter o mesmo comprimento


8

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


1
Talvez marcar por NumberOfLanguages / CodeSize?
Ypnypn 23/02

1
@PhiNotPi Acho que "todos os programas devem ter o mesmo tamanho" ainda acrescenta muito ao concurso.
Ypnypn 23/02

5
Eu acho que isso ainda é falho. Se eu responder apenas no espaço em branco, recebo 1/0, ou seja, infinito. Caso contrário, ainda melhor responder em um único idioma, onde este é o mais curto, porque adicionar qualquer outro idioma (com código mais longo) reduz minha pontuação.
Martin Ender

1
Além disso, seu argumento sobre ter programas mais longos reduz sua pontuação está incorreto. Se eu postar um programa de tamanho 10, minha pontuação será 0,1. Se eu publicar três programas de duração 20, minha pontuação é 0,15, o que é mais alto. Um tamanho de código menor não significa uma pontuação mais alta automaticamente.
FUZxxl

5
-1 por desincentivar apenas jogando em idiomas obscuros e obscuros por diversão, em uma [pedra-de-roseta].
algorithmshark

Respostas:


7

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

Como eu executo isso? Mmhdcr1GH100 7não funciona como eu pensava.
Mbomb007

1
@ mbomb007 Mdefine uma função gque você deve chamar primeiro. Tente Mmhdcr1GHg100 7.
Jakube 24/02

%é a mesma coisa que python [::a]. Não há necessidade de cortar. E tenho certeza de que seu alcance precisa incluir G, por exemplo, o uso r1hG.
Jakube 24/02

@Jakube graças para a ponta
Maltysen

Por favor, coloque um espaço antes 7. Negativo não parece certo.
Mbomb007

9

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

1
Como você possui o Matlab, por que não adicionar o Octave?
Alephalpha #

Isso pode funcionar. O código seria exatamente o mesmo?
Lynn

Sim, é exatamente o mesmo.
alephalpha

Arrumado. Eu adicionei!
Lynn

jrojcoq-]m[m]uNseria uma versão burlesca que gera número e não envia dados fictícios para a pilha apenas para exibi-los novamente.
mroman

4

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]

Tecnicamente, o Burlesque tem um comando "EveryNth". Como o 100ro7en?ique produz {8 15 22 29 36 43 50 57 64 71 78 85 92 99}. Você pode diminuir ainda mais usando 7mo14.+?i.
Mroman 12/05

@mroman Faz muito tempo desde que escrevi este código. Mas, tanto quanto me lembrei, o comando "EveryNth" não funciona como o [::a]comando em Python. EveryNth([1,2,3,4,5,6,7,8, 9], 3)retorna [3, 6, 9]e não [1,4,7], como foi exigido neste desafio.
Jakube 12/05

Sim, você está certo. Os entrabalhos diferentes do que se esperaria de outros idiomas. Amaldiçoo o dia em que o implantei desta maneira: D. Soluções comuns para isso estão usando o que moeu mencionei acima ou usando cocomo na 9ro3co)-]qual produz {1 4 7}. PS: Eu tinha um intérprete on-line nos velhos tempos, mas meu novo hoster não suporta mais CGI, mas posso convencer alguém que possui um servidor com suporte a CGI a hospedar o intérprete on-line novamente :)
mroman

4

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

Observe que seu programa> <> conta de trás para frente de n para um ignorando s, produzindo 2 9 16 23 30 37 44 51 58 65 72 79 86 93 100 para n = 100, s = 7 em vez de 1 8 15 22 29 36 43 50 57 64 71 78 85 92 99, conforme especificado no exemplo do OP.
cirpis

@cirpis Eu consertei> <>, ainda tenho que consertar o Befunge.
mbomb007

Em vez de assumir que tudo está na pilha para> <>, acho que você pode usar o sinalizador -v para fornecer entrada. Bandeiras normalmente adicionar um byte, mas eu não tenho certeza se isso significa que você precisa remover um char lixo ou não (uma vez que, aparentemente, só se preocupam com "tamanho do código")
SP3000

Vejo pessoas assumindo que o material está na pilha o tempo todo para Befunge, GolfScript, etc. Mas não sei como inserir, além de i, o que empurra um caractere. Além disso, enquanto estamos no assunto, é aceitável que o programa trave após concluir com êxito sua saída (exibindo uma pilha vazia)?
Mbomb007

1
@ mbomb007 Com seq.int(). Funciona da mesma forma que rangeem Python. Depois, você pode obtê-lo para 29.
freekvd

3

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

Se você quiser outro idioma, aqui está o STATA:di _reque(s) _reque(n) gl a=1 while $a<=$n{ di $a gl a=$a+$s }
bmarks

@bmarks Obrigado, parece um pouco idiota adicionar o código de outra pessoa à resposta;)
Teun Pronk

Na função javascript, acho que você precisa de i <= n em vez de i <n. Além disso, acho que você pode encurtar a maioria deles usando a função de alerta em javascript e encurtando nomes de variáveis ​​nos outros.
bmarks

@ marca os nomes das variáveis ​​com 1 caractere cada, o mesmo para os nomes das funções. Eu apenas as acolchoei um pouco para que elas tivessem o mesmo comprimento. e você está certo sobre o javascript. Vou mudar isso.
Teun Pronk

Eu conto apenas 50 caracteres na solução Ruby.
Jakube 25/02

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.