Назад
 Начало |
 Учебные материалы |
Подразделы
Другие разделы
Дата и время
05/12/2025 18:41:45
Введение
Парадигмы программирования Классификация и сравнение языков программирования Тест производительности 1 Тест производительности 2
Тест производительности 1
Задача [В обратном порядке](210-2.html?problem=2730). Ввод и вывод `10^6` целых чисел.
||.u|С++||
```cpp
#include <vector>
#include <iostream>
using namespace std;
int main()
{ ios::sync_with_stdio(0); // для ускорения ввода
cin.tie(0);
int n;
cin>>n;
vector<int> a(n);
for(auto& ai: a)
cin>>ai;
for(int i=n-1; i>=0; --i)
cout<<a[i]<<(i>0?' ':'\n');
}
```
||.u|С||
```c
#include <stdio.h>
int main()
{ int n;
scanf("%d",&n);
int a[n];
for(int i=0; i<n; ++i)
scanf("%d",&a[i]);
for(int i=n-1; i>=0; --i)
printf("%d%c",a[i],i>0?' ':'\n');
}
```
||.u|Pascal||
```pascal
{Free Pascal}
var n,i:integer;
a: array of integer;
begin
read(n);
SetLength(a, n);
for i:=0 to n-1 do
read(a[i]);
for i:=n-1 downto 0 do
write(a[i],' ');
writeln;
end.
```
```pascal
{PascalABC.NET}
var n:integer;
a: array of integer;
begin
reset(input,'input.txt'); { буферизация ввода и вывода}
rewrite(output,'output.txt');
read(n);
SetLength(a, n);
for var i:=0 to n-1 do
read(a[i]);
for var i:=n-1 downto 0 do
write(a[i],' ');
writeln;
end.
```
||.u|Python||
```python
{обычный ввод}
n=int(input())
a=[int(x) for x in input().split()]
print(*reversed(a))
```
```python
{ввод через readline}
from sys import stdin
n=int(stdin.readline())
a=[int(x) for x in stdin.readline().strip().split()]
print(*reversed(a))
```
```python
{ввод-вывод через pcio}
import pcio
n=pcio.input('i')
a=pcio.input(n,'i')
pcio.println(reversed(a))
```
||.u|Lua||
```lua
n=io.read("n")
a = {}
for i = 1, n do
a[i] = io.read("n")
end
for i = n,1,-1 do
io.write(a[i].." ")
end
io.write("\n")
```
||.u|JavaScript||
```js
let n=input('n')
let a=input(n,'n')
print(a.reverse().join(" "))
```
||.u|Java||
```java
import java.io.*;
import java.util.StringTokenizer;
public class program {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter wr = new BufferedWriter(new OutputStreamWriter(System.out));
int n = Integer.parseInt(br.readLine());
int[] a=new int[n];
StringTokenizer st = new StringTokenizer(br.readLine());
for(int i=0; i<n; ++i) {
a[i]=Integer.parseInt(st.nextToken());
}
for(int i=n-1; i>=0; --i) {
wr.write(Integer.toString(a[i]));
wr.write(" ");
}
wr.newLine();
wr.close();
}
}
```
||.u|C#||
```cs
using System;
using System.Text;
namespace MyApplication
{
class Program
{
static void Main()
{ int n=Convert.ToInt32(Console.ReadLine());
int[] a = Array.ConvertAll(Console.ReadLine().Split(new char[] { ' ' },
StringSplitOptions.RemoveEmptyEntries), s=>Convert.ToInt32(s));
Array.Reverse(a);
Console.WriteLine(String.Join(" ", a));
}
}
}
```
||.u|Kotlin||
```kotlin
fun main() {
val n=readln().toInt()
val a=readln().split(" ").map{ it.toInt() }
println(a.reversed().joinToString(separator=" "));
}
```
||.u|Rust||
```rust
#[macro_use]
extern crate text_io;
fn main() {
let n: usize;
scan!("{}",n);
let mut a = vec![0i32; n];
for i in 0..n {
scan!("{}",a[i]);
}
for i in (0..n).rev() {
print!("{}{}", a[i], if i != 0 { ' ' } else { '\n' });
}
}
```
||.u|go||
```go
package main
import ( "bufio"; "fmt"; "os")
func main() {
reader := bufio.NewReader(os.Stdin)
writer := bufio.NewWriter(os.Stdout)
var n int
fmt.Fscan(reader, &n)
a := make([]int, n)
for i := range a {
fmt.Fscan(reader, &a[i])
}
for i := len(a) - 1; i >= 0; i-- {
fmt.Fprint(writer, a[i], " ")
}
fmt.Fprintln(writer)
writer.Flush()
}
```
||.u|Dart||
```dart
import 'dart:io';
void main() {
final lines=File('input.txt').readAsLinesSync(); { буферизированный ввод }
final n = int.parse(lines[0].trim());
final a = lines[1].trim().split(' ').map(int.parse).toList();
print(a.reversed.join(" "));
}
```
||.u|Prolog||
```prolog
:-initialization(main).
read_list(0,[]).
read_list(N,[H|T]):-N>0, read_integer(H), N1 is N-1, read_list(N1,T).
print_reverse([H]):-write(H).
print_reverse([H|T]):-print_reverse(T), write(' '), write(H).
main:-read_integer(N), read_list(N,L), print_reverse(L), nl.
```
||.u|Scheme||
```scheme
(define (read_list N)
(if (= N 0) '()
(cons (read) (read_list (- N 1)))
)
)
(define (print_reverse L)
(if (null? (cdr L)) (display (car L))
(begin
(print_reverse (cdr L))
(display " ")
(display (car L))
)
)
)
(let ((N (read)))
(print_reverse (read_list N))
(newline)
)
```
||.u|Haskell||
```haskell
getList :: IO [Int]
getList = map read . words <$> getLine
main = do
n <- getLine
a <- getList
putStrLn (unwords (map show (reverse a)))
```
