Braking distance

Rozwiązanie zadania: Braking distance z High School Programming League 2010/2011 w różnych językach programowania.

C/C++

#include<stdio.h>
int main(){
	double a;
	scanf("%lf", &a);
	printf("%.1lf\n", (48.0*a*a)/10000.0);
	return 0;
}

Java

public class Main {
    public static void main(String[] args) throws java.lang.Exception {
        java.io.BufferedReader r = new java.io.BufferedReader(new java.io.InputStreamReader(System.in));
        Float f = Float.parseFloat(r.readLine());
        System.out.printf("%.1f\n", (48 * f * f) / 10000.0);
    }
}

Python

import sys
def main():
	n = float(input())
	print("%.1f" % ((48.0 * n * n)/10000.0))
if __name__ == '__main__':
	main()

Pascal

program braking_distance;

var
	a : real;
begin
	readln(a);
	writeln((48.0*a*a)/10000:0:1);
end.

Ruby

n = readline.to_f
printf "%.1f\n", (48.0*n*n)/10000.0

D

import std.cstream;
import std.stdio;
void main(){
	float n;
	din.readf(&n);
	writefln("%.1f", (48.0*n*n)/10000.0);
}

C#

using System;

namespace Program{
	class Program{
		static void Main(string[] args){
			double n = Convert.ToDouble(Console.ReadLine());
			Console.WriteLine(String.Format("{0:F1}", (48.0*n*n)/10000.0));
		}
	}
}

Fortran

IMPLICIT NONE
REAL(8) :: a
READ *,a
PRINT "(1F0.1)", 48.0*a*a/10000.0
END

Pike

#!/usr/local/bin/pike

import Stdio;

int main(){
	float n;
	sscanf(stdin->gets(), "%f", n);
	write("%.1f\n", 48.0*n*n/10000.0);
	return 0;
}

Perl

#!/usr/bin/perl
 
$n = <STDIN>;
$val = 48.0 * $n * $n / 10000.0;
printf "%.1f\n", $val; 

Lua

n = io.read("*number")
print(string.format("%.1f", (48 * n * n) / 10000)) 

Nemerle

using System;
using System.Console;
public class Program{
	public static Main () : void{
		def n = Int32.Parse(ReadLine());
		Console.WriteLine(String.Format("{0:F1}", (48.0*n*n)/10000.0));
	}
}

Go

package main

import "fmt"

func main() {
	n:=0.0
	fmt.Scanln(&n)
	fmt.Printf("%.1f\n", 48.0 * n * n / 10000.0)
}

Lisp

(let ((n (read)))
	(setq v (/ (* 48 (* n n)) 10000))
	(format t "~1$" v)
)

Nasm


section .bss
        buffer          resb    1

section .text
        global _start
section .data
_start:
				mov eax, 255
				push eax
				call ReadChar
				sub eax, '0'
				push eax
		;; [A..
				call ReadChar
				cmp eax, 10
				je number_end
		;; [AB.
				sub eax, '0'
				push eax
				call ReadChar
				cmp eax, 10
				je number_end
		;; [ABC]
				sub eax, '0'
				push eax
				call ReadChar
				cmp eax, 10
				je number_end
		;; na stos dodawane sa kolejne cyfry, a na szczycie jest informacja o ilosci cyfr
		;; na dnie 255 - znacznik konca stosu
number_end:
				pop ecx
				pop eax
				cmp eax, 255
				je get_val

				mov edx, 10
				mul edx
				add ecx, eax

				pop eax
				cmp eax, 255
				je get_val

				mov edx, 100
				mul edx
				add ecx, eax
get_val:
				mov eax, ecx
multi_division:	
				mul ecx
				mov ecx, 48
				mul ecx

				xor edx, edx
				mov ecx, 10000
				idiv ecx
prepare_print:
				push eax		; czesc calkowita wrzucona na stos
				mov eax, edx
				xor edx, edx
				mov ecx, 1000
				idiv ecx
				cmp edx, 500
				jb dont_increment
				inc eax
dont_increment:	
				add eax, '0'
				pop ebx
				mov ecx, 255	; znacznik konca stosu
				push ecx
				push eax		; cyfra po kropce wrzucona na stos
				mov eax, '.'
				push eax		; kropka wrzucona na stos
				mov eax, ebx
divide:	
				xor edx, edx
				mov ecx, 10
				idiv ecx
				add edx, '0'
				push edx
				cmp eax, 0
				jne divide
print:
				pop eax
				cmp eax, 255
				je _end
				call PrintChar
				jmp print
_end:
				mov eax, 10
				call PrintChar
				mov eax, 1
				xor ebx, ebx
				int 80h


;------ ReadChar --------------------
; wczytuje jeden znak ze standardowego wejscia do EAX
ReadChar:
				push edx

				mov eax, 3
				xor ebx, ebx
				mov ecx, buffer
				mov edx, 1
				int 80h
				mov eax, [ecx]

				pop edx
				ret


;------ PrintChar ------------------
; drukuje znak z EAX na standardowe wyjscie
PrintChar:
				push eax
				push edx

				mov [buffer], eax
				mov eax, 4
				mov ebx, 1
				mov ecx, buffer
				mov edx, ebx
				int 80h

				pop edx
				pop eax
				ret

Erlang

-module(tested).
-export([main/0]).

main() ->
  {ok, [X]} = io:fread("","~d"),
  io:fwrite("~.1f~n", [48.0 * X * X / 10000.0]).

Ocaml

let _ =
  let n = read_float () in
  let v = 48.0 *. n *. n /. 10000.0 in
  Printf.printf "%.1f\n" v;

Posted on 18/05/2011, in Programowanie. Bookmark the permalink. Dodaj komentarz.

Skomentuj

Wprowadź swoje dane lub kliknij jedną z tych ikon, aby się zalogować:

Logo WordPress.com

Komentujesz korzystając z konta WordPress.com. Log Out / Zmień )

Zdjęcie z Twittera

Komentujesz korzystając z konta Twitter. Log Out / Zmień )

Facebook photo

Komentujesz korzystając z konta Facebook. Log Out / Zmień )

Google+ photo

Komentujesz korzystając z konta Google+. Log Out / Zmień )

Connecting to %s

%d bloggers like this: