Mein Roboter ist irgendwie kurzgeschlossen und irgendwo von meinem Labor weggelaufen!

Glücklicherweise beginnt jedes Mal, wenn er dies tut, seine Abschaltsequenz, sodass er genug Zeit hat, sich nach dem Zufallsprinzip zu drehen und fünf Runden lang in die Richtung zu rennen, in die er weist, bevor er abschaltet. Seine Kreisel- und Beschleunigungsmesserfunktionen leiten die Daten immer noch an das Labor weiter, solange er noch eingeschaltet ist.

Die Daten werden beispielsweise immer in Form von fünf Sätzen zu je zwei Zahlen vorliegen.

12:234,-135:47,-68:230,140:324,127,87

Ihre Mission ist Golfer a) simuliert den hektischen Lauf des Roboters und Sequenz dreht durch die Anzeige fünf Sätze von Zahlen in Form von a1:d1,a2:d2,a3:d3,a4:d4,a5:d5wo a(n) ist der Winkel im Uhrzeigersinn (in Grad) , so dass -179<=a<=+180der Roboter von seiner aktuellen Position drehen wird ( anfangs ist es auf null, bevor es amok läuft und sich zum ersten Mal dreht) und d(n) ist die Entfernung in Fuß, die es vor dem nächsten Richtungswechsel zurückgelegt hat, und zwar so, dass die 0<=d<=500Füße; und b) eine berechnete Überschrift aus dem Labor (die ebenfalls einer Überschrift von Null zugewandt ist), eine Entfernung in Fuß (Genauigkeit bis zu 3 Dezimalstellen wird dringend empfohlen, wenn Sie dies tun, -5 Byte) und die Orientierungsüberschrift (in Grad). von wo mein Roboter ist es ausgerichtet, wenn es ausgeschaltet ist.

Einfaches Beispiel:

Data: 0:1,45:1,90:1,90:1,90:1
Heading: 0
Distance: 1
Orientation: -45

Die zufälligen Kurven und Entfernungen sind genau das, zufällig. Es dürfen keine festgelegten Werte fest codiert werden, wir müssen die Zufälligkeit im Code in Aktion sehen.

Einschränkungen der Zufälligkeit: Keine auf der Uhr oder dem Datum basierenden Verweise. Wir benötigen einen systemeigenen randomVerweis im Code. Wann immer Sie diesen Code ausführen, muss die Zufälligkeit die Möglichkeit bieten, 1 von 360 möglichen Drehwinkeln bei jeder Umdrehung anzuzeigen. Der Roboter kann sich also in einer Umdrehung um -36 Grad drehen und in der nächsten um +157 Grad, gefolgt von einer weiteren Umdrehung um +2 Grad um -116 Grad und einer letzten Umdrehung um +42 Grad in der letzten Umdrehung. Bei jeder zufälligen Winkelerzeugung müssen mindestens 360 verschiedene Werte möglich sein (zwischen -179 und +180 Grad einschließlich).

Einschränkungen beim Streckenlauf: Ähnlich eingestellt, gibt es 501 mögliche Strecken, die der Roboter laufen kann (zwischen 0 und 500 Fuß einschließlich). Daher erwarte ich, dass die Zufälligkeit auch bei der Ermittlung der Laufstrecke des Roboters verfügbar ist. Der Roboter könnte theoretisch 45, 117, 364, 27 und 6 Fuß mit jeder seiner jeweiligen Runden laufen ...

Die Ihnen zugeführten Daten sind immer ganzzahlig ... der Roboter dreht sich in ganzzahligen Gradbereichen und läuft in ganzzahligen Entfernungsbereichen. Die Ausgabewerte werden jedoch float sein ...

Das ist Code-Golf. Kürzester Code gewinnt ... Jetzt geh und finde meinen Roboter!

PS: In Bezug auf meine "Genauigkeit bis zu 3 Nachkommastellen" können Sie die Überschrift (in Grad, auf ein Minimum von 3 Nachkommastellen) und einen Abstand in Fuß (auch genau, auch auf ein Minimum von 3 Nachkommastellen) angeben wird ein -5 Byte Bonus bekommen).

Perl 6: 188 184 Zeichen - 5 = 180 Punkte

$_=((-179..180).pick=>(^501).pick)xx 5;my$o;$/=([+] .map:{unpolar .value,$o+=.key/($!=180/pi)}).polar;say "Data: {.fmt("%d:%d",",")}
Heading: {$1*$!}
Distance: $0
Orientation: {$o*$!}"

Golf mit Leerzeichen:

$_ = ((-179..180).pick => (^501).pick) xx 5;
my $o;
$/ = ([+] .map: {
    unpolar .value, $o += .key / ($!=180/pi)
}).polar;
say "Data: {.fmt("%d:%d", ",")}
Heading: {$1*$!}
Distance: $0
Orientation: {$o*$!}"

Ungolfed:

my &postfix:<°>  = */180*pi; # Deg → Rad
my &postfix:<㎭> = */pi*180; # Rad → Deg

my @data = ((-179..180).pick => (0..500).pick) xx 5;
say "Data: @data.fmt("%d:%d", ",")";

my $cum-angle = 0;
my $complex = [+] @data.map: {unpolar .value, $cum-angle += .key°}
my ($dist, $ang) = $complex.polar;

say "Heading: ",     $ang.㎭;
say "Distance: ",    $dist;
say "Orientation: ", $cum-angle.㎭;

Dadurch wird die Daten in komplexe Zahlen mit unpolar, legt die Summe von ihnen in $complexund bekommt dann die Polarkoordinaten als $dist, $ang.

Der kumulative Winkel $cum-anglewird erfasst, weil die Winkel relativ zum Roboter sind, wenn er sich durch das Labor bewegt, und weil wir den endgültigen Winkel des Roboters für unsere Ausgabe benötigen.

Beispielausgabe:

Data: -73:230,-144:453,-151:274,-52:232,88:322
Heading: -5.33408558001246
Distance: 378.74631610127
Orientation: -332

Der einzige wirkliche Trick, den der Golf benutzt, ist, dass er alle drei speziellen Variablen von Perl 6 (falsch) benutzt, um eine gute Wirkung zu erzielen:

• $! wird für Bogenmaß ↔ Grad verwendet
• $_enthält die Daten, und alles, was einsam aussieht, .method()bedeutet tatsächlich $_.method()(außer im map {…}Block, wo $_tatsächlich der Wert der Zahlenpaare übernommen wird, aus denen die Daten bestehen)
• $/hält was in der ungolfed version ($dist, $ang). $0und $1tatsächlich bedeuten $/[0], dh $dist, und $/[1], dh,$ang

Ruby, 274 252 249 245 214 211 207 204 202 Zeichen (-5 = 197)

Wie hat PHP Ruby in char count geschlagen ?! >: O muss einen Weg zum Golf finden mehr ...

Bearbeiten: Ich habe die PHP-Antwort geschlagen, aber der Benutzer, der sie geschrieben hat, hat mir dabei geholfen! Geh und stimme ihm zu. er hat es verdient :-P

Noch eine Änderung: Gah! Er hat mich wieder passiert! Du bist ein sehr würdiger Gegner, @MathieuRodic; Glückwunsch, ich muss dich gewinnen lassen ;-)

P=(M=Math)::PI
puts"Data: #{([x=y=a=0]*5).map{a+=o=rand -179..e=180;x+=M.sin(b=a*P/e)*d=rand 500;y+=d*M.cos b;"#{o}:#{d}"}*?,}
Heading: #{M.atan(y/x)/P*-e+90}
Distance: #{M.hypot x,y}
Orientation: #{a}"

Ungolfed Code (und etwas ältere Version):

data = Array.new(5) { [rand(-179..180), rand(0..500)] }
puts "Data: #{data.map{|x|"#{x[0]}:#{x[1]}"}.join ?,}"
x, y, a = [0] * 3
data.each do |o, d|
    a += o
    x += Math.sin(a * Math::PI / 180) * d
    y += Math.cos(a * Math::PI / 180) * d
end
puts "Heading: #{Math.atan(y / x) / Math::PI * -180 + 90}
Distance: #{Math.sqrt(x * x + y * y)}
Orientation: #{a}"

Beispielausgabe:

c:\a\ruby>robotgolf
Data: 94:26,175:332,14:390,159:448,-45:20
Heading: 124.52305879195005
Distance: 279.5742334385328
Orientation: 397

PHP - 238 232 221 212 203 199 Zeichen

for(;$i<5;$h+=$a=rand(-179,181),$x+=cos($b=$a*$k=M_PI/180)*$l=rand(0,501),$y+=$l*sin($b),$d.=($i++?",":"")."$a:$l");echo"Data: $d
Heading: $h
Distance: ".hypot($x,$y)."
Orientation: ".atan2($y,$x)/$k

(Teste es hier: http://ideone.com/dNZnKX )

Nicht Golf Version:

$k = M_PI / 180;
$h = $x = $y = 0;
$d = "";

for ($i=5; $i--;){
    $h += $a = rand(-179,181);
    $x += ($l = rand(0, 501)) * cos($b = $k * $a);
    $y += $l * sin($b);
    $d .= ($d ? "," : "") . "$a:$l";
}

echo "Data: $d\nHeading: $h\nDistance: " . sqrt($x*$x + $y*$y) ."\nOrientation: " . atan2($y, $x)/$k . "\n";

(Teste es hier: http://ideone.com/1HzWH7 )

Python - 264 259 256 258 - 5 = 253 Zeichen

from math import*;import random as R;r,k,d=R.randint,pi/180,[];h=x=y=0;exec"a,l=r(-179,180),r(0,500);d+=[`a`+':'+`l`];h+=a;x+=l*cos(k*a);y+=l*sin(k*a);"*5;print('Data: %s\nHeading: %d\nDistance: %.3f\nOrientation: %d'%(','.join(d),h,hypot(x,y),atan2(y,x)/k))

(Teste es unter http://ideone.com/FicW6e )

Ungolfed-Version:

from math import *
from random import randrange as r

k = pi / 180
h = x = y = 0
d = []
for i in range(5):
    a = r(-179,181)
    l = r(501)
    d += ['%d:%d' % (a, l)]
    h += a
    x += l * cos(k * a)
    y += l * sin(k * a)

print('Data: %s\nHeading: %d\nDistance: %.3f\nOrientation: %f' % (','.join(d), h, sqrt(x*x+y*y), atan2(y,x)/k))

(Test unter http://ideone.com/O3PP7T )

NB: viele Antworten enthalten -5 in ihrem Titel, während ihr Programm die Distanz nicht mit einer Genauigkeit von bis zu 3 Dezimalstellen darstellt ...

Python 301-5 = 296

from math import*
r=__import__("random").randint
o=x=y=0
s=[]
for i in[0]*5:a=r(-179,180);d=r(0,500);o+=a;o+=180*((o<-179)-(o>180));n=pi*o/180;x+=d*cos(n);y+=d*sin(n);s+=["%d:%d"%(a,d)]
print"Data: "+",".join(s)+"\nHeading: %d"%degrees(atan(y/x))+"\nDistance: %f"%sqrt(x**2+y**2)+"\nOrientation: %d"%o

Nichts Besonderes, eher wortreich. Dies ist ein Problem, für das ich nicht glücklich bin, dass die Triggerfunktionen von Python im Bogenmaß arbeiten.

> python robot.py
Data: 17:469,110:383,-146:240,-78:493,62:1
Heading: -17
Distance: 405.435748
Orientation: -35
> python robot.py
Data: -119:363,89:217,129:321,10:159,-56:109
Heading: -79
Distance: 130.754395
Orientation: 53

Python 2 = 376 319 Zeichen (-5 für Entfernung = 314)

import random,math
h=x=y=0
for i in range(5):
    a=random.randint(-179,180)
    d=random.randint(0,500)
    print '%d:%d,'%(a,d),
    h+=a
    if h>180:
        h-=360
    x+=d*math.cos(h)
    y+=d*math.sin(h)
t=math.sqrt(x**2+y**2)
o=math.atan2(y,x)
print
print 'Heading: %d\nDistance: %3f\nOrientation: %d' % (h,t,o)

Beispielausgabe

-141:245, 56:355, 145:223, -10:80, -38:253,
Heading: 12
Distance: 559.031404
Orientation: -2