Rosetta Stone Code-Herausforderungen sind Herausforderungen, bei denen Sie die Aufgabe in möglichst vielen Sprachen ausführen müssen.

Die Herausforderung

Sie erhalten zwei Zahlen nund sin einer Liste als Eingabe. Das nwird eine Zahl , die Sie haben zu zählen bis zu. nist eine beliebige Zahl von 2 bis 10000. sist die Zahl, die Sie beim Zählen bis überspringen n. swird von 1 bis n/ 2 (die Hälfte von n) sein. Wenn n600 war, skönnte 300 nicht größer sein. Sie müssen alle Zahlen bis zum nÜberspringen sausgeben, indem Sie mit 1 beginnen. Jede Ausgabenummer sollte sich entweder in einer neuen Zeile, in derselben durch Leerzeichen getrennten Zeile oder in einer Liste befinden.

Die Wendung

Für diese Rosetta Stone Code Challenge muss jedes Snippet, in das Sie das Programm schreiben, dieselbe Länge haben. dh: Wenn Ihr Python-Programm 56 Zeichen hat, muss Ihr Java-Programm auch 56 Zeichen haben. Leerzeichen und Kommentare zählen nicht als Zeichen. Variablen- / Funktionsnamen dürfen nicht länger als 10 Zeichen sein. Denken Sie daran, dass dies auch Code Golf ist. Versuchen Sie also, Ihren Code kurz zu halten.

Beispiel

Eingang

[100, 7]

Ausgabe

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

Hinweis: Die Ausgabe kann in einer einzelnen Zeile erfolgen, die durch Leerzeichen oder Listenformat getrennt ist

Gewinnkriterium

Der Gewinner wird nach folgender Formel ermittelt:

numberOfLanguages/codeSize

codeSize ist nicht die Gesamtcodegröße, sondern die durchschnittliche Codegröße eines Snippets.

Der Benutzer mit der höchsten Punktzahl gewinnt. dh: Eine Antwort mit 4 Sprachen und einer Größe von 31 Bytes würde eine Antwort mit 7 Sprachen und einer Größe von 80 Bytes gewinnen. Ein Gewinner wird am 9. März 2015 um 2:00 UTC ausgewählt.

Anzeigetafel

^{Alle Punkte werden auf das nächste Tausendstel gerundet}

Maltysen - 14 Sprachen / 24 Zeichen = 0,583 ---- Gewinner

mbomb007 - 15 Sprachen / 29 Zeichen = 0,517

Jakube - 5 Sprachen / 11 Zeichen = 0,455

Teun Pronk - 4 Sprachen / 51 Zeichen = 0,078

captncraig - 1 Sprache / 56 Zeichen = 0,018

14 Sprachen - 24 Bytes = 0,58333333333

** Gesichtspalme **. Ich habe vergessen, den Platz in meiner Python-Antwort nicht zu zählen. Also bin ich jetzt bei 24 Bytes.

Ich habe aus dieser Herausforderung viele neue Sprachen gelernt, die ich wahrscheinlich beim Golfspielen verwenden werde. Eine Website, die mir wirklich geholfen hat, diese Sprachen zu finden, war http://www.tutorialspoint.com/codingground.htm . Erwarten Sie nur nicht, dass meine Programme darin ausgeführt werden. Es ist ein vollständiges Programmformat erforderlich. Ich habe es nur verwendet, um die Sprachen kennenzulernen, und andere REPLs verwendet, um sie auszuführen.

1. Pyth :

Pyth hat keinen Bereich für Schritt Funktion im Gegensatz zu Python, so dass ich regelmäßig Bereich verwendet und gehackt (dank @Jakube) verwendete mod Betreiber darauf.

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

Definiert eine Funktion g (bis, Schritt)

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

2. Golfscript:

Dies ist mein erstes Golfscript-Programm. Wahrscheinlich nicht der beste Weg, es zu tun.

000000000000000;\),1>\%p

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

3. Bash Utils:

Verwendet den Befehl seq mit dem Parameter INCREMENT.

seq 00000000000000001 $2 $1

4,5. Python, Salbei :

Selbsterklärender Code.

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

Sage ist eine Sprache, die auf Python basiert und für Mathematik verwendet wird.

6. Mathematica:

Wieder selbsterklärend.

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

7. Matlab:

Verwendet die Bereichsnotation von Matlab und definiert eine anonyme Funktion.

@(a,b)00000000000001:b:a

8. Livescript:

Wie Coffeescript ist es ein JS-Derivat. Hat coole Range-Syntax. Pfeilnotation wieder.

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

9. Erlang:

Erlernte erlang nur dafür. Ziemlich selbsterklärend, definiert Funktion r.

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

10. F #:

Offensichtlich sind die Funktionsdefinitionen von F # wie Variablen.

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

11. Haskell:

In der Bereichsnotation von Haskell geben Sie die ersten beiden im Bereich für das Inkrement an und kein explizites Inkrement.

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

12. R:

Sehr coole Sprache, auch wenn die Funktionsdefinitionen etwas ausführlich sind.

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

13. Julia:

Tolle Sprache, wird in Zukunft zum Golfen verwendet.

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

14. CJam:

Wie meine alte Golfscript-Antwort, außer mit Eingabe-Parsing und Padding.

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

23 Sprachen, 15 Zeichen = 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 Sprachen 11 Zeichen = 0,4545

Ich nutzte diese Herausforderung als Gelegenheit, um einige neue Sprachen (CJam, Burlesque, zsh, gs2) auszuprobieren. Zum ersten Mal habe ich mit diesen Sprachen gearbeitet.

Die Methode zum Erstellen der Ausgabe ist in fast jeder Sprache unterschiedlich. Nur die CJam- und die gs2-Methode sind identisch. Die 4 Methoden sind, einen Bereich [1, 100] zu erstellen und ihn mit Modulo (CJam und gs2) zu schneiden, den Bereich [1, ..., 100] zu erstellen und nach Elementen zu filtern, die 1 Mod 7 (Pyth) sind, zu erstellen Teilen Sie den Bereich [1, ..., 100] in Blöcke von Länge 7 auf, verwenden Sie das erste Element jedes Blocks (Burlesque) und erstellen Sie die Sequenz direkt (zsh).

Ich habe versucht, jedes Programm so zu gestalten, dass es für jemanden, der mit der Sprache nicht vertraut ist, wie ein Golfspiel aussieht.

edit 1: Burlesque hinzugefügt, vorherige 2 Sprachen mit 10 Zeichen = 0,2

edit 2: gs2 hinzugefügt, vorherige 3 Sprachen mit 11 Zeichen = 0,2727

edit 3: zsh hinzugefügt, vorherige 4 Sprachen mit 11 Zeichen = 0,3636

CJam

q~\1+,0-\%p

Testen Sie es online mit der Eingabe 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

Burleske

jrojcoq-]m[

Neben zsh ist dies das einzige Golfprogramm. Burlesque ist ziemlich genial, es hat eine sehr große Auswahl an verschiedenen Funktionen, wie z ro. Leider gibt es nichts Schöneres als den Python- [::a]Slicing-Operator.

Es gibt keinen Online-Dolmetscher, aber Sie können Burlesque hier bekommen . Da Burlesque keine Funktionen oder E / A unterstützt, müssen Sie die Werte zuerst auf den Stapel legen, z100 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

Ja, das sind nur 11 Zeichen. In gs2 hat jedes Byte eine andere Bedeutung. Da das Schreiben in Bytes jedoch ziemlich schwierig ist und keinen Spaß macht, können Sie auch in Mnemonics schreiben, die Sie mit dem eigentlichen gs2-Code kompilieren können. Der gs2-Code, der ausgeführt wird, ist

W@!'."B !4+

oder als Hex-Dump:

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

Lustige Tatsache: Ich habe nicht in Mnemonik geschrieben, sondern direkt die Nummern des Hex-Dumps.

Sie können es testen, indem Sie den Compiler herunterladen . Kompilieren Sie die Mnemonics-Datei mit python gs2c.py < mnemonics.txt > compiledoder kopieren Sie W@!'."B !4+sie einfach in eine Datei mit dem Namen compiledund führen Sie sie dann mit aus echo 100 7 | python gs2.py compiled.

Die Mnemonik ist ziemlich selbsterklärend, aber hier ist, was im Stapel vor sich geht.

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

Übrigens sind 8 Bytes möglich, vielleicht sogar weniger.

edit: Ich habe gs2 gegabelt, einen Befehl leicht manipuliert und eine Pull-Anfrage gestellt, die bereits zusammengeführt ist. Jetzt kann die Aufgabe mit 6 Bytes erledigt werden:, read-nums extract-array swap range1 mod unlineswas übersetzt bedeutet 57 0e 42 2f 34 2b, was sogar besser ist als der optimale Python.

zsh

f() seq 1 $2 $1

Dies definiert eine Funktion f, die eine Sequenz erstellt. Um es unter Windows zu verwenden, habe ich die Babun- Shell installiert , in die Sie diese Befehle einfach eingeben können. Einfach schreiben f() seq 1 $2 $1und in die nächste Zeile f 100 7.

Zuerst habe ich versucht, dies in Bash zu schreiben, aber dort muss man ()um den Codeblock herum schreiben , wie f() ( seq 1 $2 $1 ). Also wechselte ich stattdessen zu zsh.

Pyth

fq1%TeQUhhQ

Das tut wirklich weh, da ich natürlich das offensichtliche 7-Byte-Golf sehe. Sie können es online mit der Eingabe testen 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 Sprachen, 29 Zeichen = (15/29) ≈ 0,517

Ich habe bisher meinen gesamten Code repariert. Jetzt suche ich nach anderen Sprachen.

1. Python (24 Golf)

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

2.> <> (Fisch) - (19 + Junk-Zeichen)

Dieses Programm geht davon aus, dass sich die Anzahl und die Schrittgröße zuvor auf dem Stapel befanden und in dieser Reihenfolge verschoben wurden. Uses aoZeilenumbrüche zwischen den Zahlen zu drucken.

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

Erläuterung (Code, Stapel nach Ausführung des vorhergehenden Codes, Kommentare):

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

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

Golf gespielt . Hier einfügen: http://ngn.github.io/apl/web/

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

Rufen Sie so an : 7 f 100. Dadurch wird ein Array von 1 bis n erstellt, jedes Element mit s multipliziert, jedem Element eins hinzugefügt und dann die ersten Ceil-Elemente (n / s) verwendet.

4-7. Haskell , Clean , Curry , Frege (14 Golfplätze zählen nicht)

Dieses Programm ist in Haskell, Clean, Curry und Frege gültig.

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

Golf gespielt. Führen Sie hier aus: https://ideone.com/Ii0pgP

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

8. Scotch (15 Golf)

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

9. Jaskell (24 Golf) - Basierend auf Dokumentation gebaut.

Filtern Sie die Liste, in der die restlichen Module 1 sind.

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

10. CoffeeScript (25 Golf) Laufen Sie hier

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

11. R (25 Golf) Laufen Sie hier: http://www.r-fiddle.org/#/fiddle?id=k3vRnCOW&version=2

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

12. Cobra (26 Golf)

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

13. S-Lang (28 Golf)

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

14. Boo (29)

Nicht sicher, ob die Bereichsfunktion 3 Parameter annehmen kann ...

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

15. Funge-98 (29, Hilfe beim Golfen?)

So nah wie möglich an meinem> <> Programm. Da es keine Stapelanweisung "drehen" gibt, musste ich stattdessen "put" und "get" verwenden. Befunge braucht wirklich einige Anweisungen zum Stapeln / Verschieben des Stapels oder sogar eine "Über" -Anweisung .

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

Erläuterung:

        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)

NICHT IM MOMENT VERWENDEN, ZU LANG - Meine Punktzahl wird verbessert, indem diese nicht berücksichtigt werden .

Ruby (35) Hier ausführen : 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) Hier ausführen : https://ideone.com/HGoleN

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

4 Sprachen 51 Zeichen = (4/51) = 0,0784313725490196

Keine Ahnung, wie viele Zahlen nach dem Komma du willst, also lasse ich es einfach so.
Alle Snippets sind 51 Zeichen lang, wenn Sie alle Leerzeichen entfernen.
Arbeiten an mehr und kürzerem Code, aber es ist ein Anfang.

Log

Erste Antwort
Eingereicht Python (3.4), Lua (5.1) und Javascript.
Punktzahl: 3/51 = 0,0588235294117647

Update 1
Ruby
Score hinzugefügt: 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);
  }
}

Rubin

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

1 Sprache - 56 Zeichen = 0,01785714285

piet (2x28) -