Лучшие программисты мира боролись за звание сильнейшего

падайте. я уже выключила все лампы. растючка спит.

Пример программы ?Здравствуй, мир!?:

Проц Старт()
Вывод 'Здравствуй, мир!'
Кон Проц
Рапира.
http://c2.com/cgi/wiki?HelloWorldInManyProgramming...
Существует много способов сказать ?Hello, World!? на Brainfuck. Ниже приведен самый простой из них: использовать только одну ячейку памяти и последовательно изменять ее значение на ASCII-код каждой буквы сообщения. Каждая строка примера выводит один символ.

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
+++++++++++++++++++++++++++++.
+++++++.
.
+++.
-------------------------------------------------------------------.
------------.
+++++++++++++++++++++++++++++++++++++++++++++++++++++++.
++++++++++++++++++++++++.
+++.
------.
--------.
-------------------------------------------------------------------.

Hello, World! в Assembler
Пример для версий System/360, System/370

IBM System/360/370/390 Basic Assembler Language .

// EXEC ASSEMBLY
START
MAIN BALR 2,0
USING *,2
OPEN PRINT
MVC BUF,HW
PUT PRINT
CLOSE PRINT
EOJ
HW DC CL132'HELLO WORLD'
BUF DS CL132
PRINT DTFPR IOAREA1=BUF,DEVADDR=SYSLST,BLKSIZE=132, *
DEVICE=3203,CONTROL=YES,PRINTOV=YES
END MAIN
/*
// EXEC LNKEDT
// EXEC
/*
/&
Пойду янемногочутьчуть дринк энд слип...
:mad:

[Сообщение удалено пользователем 04.05.2013 05:17]

Вошел!
На матмехе каждый второй - еврей, это общеизвестно!

Моё кунг-фу сильнее твоего! :ultra: 8(

Не факт! У нас в группе только один еврей учился! А на факультете - тоже обсчитаться...

Что, нет желающих троллями проплаченными работать? :-D
Знаем мы ваши опросы! Как ни опрашивай, кого ни спрашивай - все равно получится 146% :ultra:

Ну, мы с Вами в разное время в универе учились.
Когда я учился, евреев на матмехе было полным-полно.
Я с ними в шахматы и в преферанс играл.

и где он сейчас? на ОНе в пьяном угаре стишки постит? :ultra: 8(

Не знаю. Додик Годелевич! Сука! :-D

:-D красавцы!

поясните кто-нибудь. Этих чемпионатов мира в каждом городе куча и все мира.

БЕГИН
WriteLn (' Вот задроты компьютерные, втроем один кубок еле подняли ))))))
ЕНД.

:-D :-D :-D

>>>сильнейшие программисты мира - студенты из России, Китая, Польши
:lol:

я "метод пузырька" в совершенстве освоил... пузырька боярки :beach:

F z b ytpyfk//.. Правда ведь капитально крышу сносит...

Примеры реализации сортировки пузырьком
Материал из Викиучебника
Перейти к: навигация, поиск
Статья ?Сортировка пузырьком? в Википедии
Содержание

1 Ассемблер
1.1 Синтаксис Intel
1.2 Синтаксис AT&T (GNU)
2 C
3 C++
3.1 С использованием Template
3.2 Без использования Template
4 C#
5 Delphi
6 D
7 Fortran
8 Java
9 Pascal
10 Perl
11 Ruby
12 Python
13 VBA
14 PHP
15 JavaScript
16 JavaFX
17 Nemerle
18 TurboBasic 1.1

Ассемблер
Синтаксис Intel

mov bx, offset array
mov cx, n
for_i:
dec cx
xor dx, dx
for_j:
cmp dx, cx
jae exit_for_j
jbe no_swap
mov ah, byte ptr bx[di]
mov byte ptr bx[di], al
mov byte ptr bx[si], ah
no_swap:
inc dx
jmp for_j
exit_for_j:
loop for_i

Синтаксис AT&T (GNU)

.text
# void bubble_sort (unsigned *array, unsigned length);
.globl bubble_sort
.type bubble_sort, @function
bubble_sort:
mov 8(%esp), %ecx # unsigned length
cmp $1, %ecx
jbe exit
mov 4(%esp), %eax # unsigned *array
dec %ecx
for_ecx:
xor %edi, %edi
for_edi:
mov (%eax,%edi,4), %ebx
cmp %ebx, 4(%eax,%edi,4)
jae no_xchng
mov 4(%eax,%edi,4), %edx
mov %edx, (%eax,%edi,4)
mov %ebx, 4(%eax,%edi,4)
no_xchng:
inc %edi
cmp %edi, %ecx
jne for_edi
loop for_ecx
exit:
ret

C

#define SWAP(A, B) { int t = A; A = B; B = t; }

void bubblesort(int *a, int n)
{
int i, j;

for (i = n - 1; i > 0; i--)
{
for (j = 0; j < i; j++)
{
if (a[j] > a[j + 1])
SWAP( a[j], a[j + 1] );
}
}
}

C++
С использованием Template

#include <algorithm>
template< typename Iterator >
void bubble_sort( Iterator First, Iterator Last )
{
while( First < --Last )
for( Iterator i = First; i < Last; ++i )
if ( *(i + 1) < *i )
std::iter_swap( i, i + 1 );
}

Без использования Template

void bubble(int*a, int n)
{
for (int i=n-1;i>0;i--)
{
for (int j=0;j<i;j++)
{
if(a[j]>a[j+1])
{
int tmp=a[j];
a[j]=a[j+1];
a[j+1]=tmp;
}
}
}
}

C#

void BubbleSort(ref int[] A)
{
int temp;

for(int i = 0; i < A.Length - 1; i++)
{
for(int j = 0; j < A.Length - i - 1; j++)
{
if(A[j] > A[j + 1])
{
temp = A[j];
A[j]=A[j+1];
A[j + 1] = temp;
}
}
}
}

Delphi

Сортировка одномерного динамического целочисленного массива:

type
TIntVec = array of Integer;
...
procedure BubbleSort(var a: TIntVec);
var i,p,n: Integer; b: boolean;
begin
n:= Length(a);
if n < 2 then exit;
repeat
b:= false;
Dec(n);
for i:= 0 to n-1 do
if a[i] > a[i+1] then
begin
p:= a[i];
a[i]:= a[i+1];
a[i+1]:= p;
b:= true;
end;
until not b;
end;

D

void bubbleSort(alias op, T)(T[] inArray) {
foreach (i, ref a; inArray) {
foreach (ref b; inArray[i+1..$]) {
if (mixin(op)) {
auto tmp = a;
a = b;
b = tmp;
}
}
}
}

Fortran

do i=n-1,1,-1
do j=1,i
if (a(j).gt.a(j+1)) then
t=a(j)
a(j)=a(j+1)
a(j+1)=t
endif
enddo
enddo

Java

void swap(int[] arr, int i, int j) {
int t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}

void bubblesort(int[] arr){
for(int i = arr.length-1 ; i > 0 ; i--){
for(int j = 0 ; j < i ; j++){
if( arr[j] > arr[j+1] )
swap(arr, j, j+1);
}
}
}

Pascal

for i:=n-1 downto 1 do {n - размер массива M[]}
for j:=1 to i do
if M[j]>M[j+1] then
begin
tmp:= M[j];
M[j]:= M[j+1];
M[j+1]:= tmp;
end;
write('вывод значений M[]: ');
for i:=1 to n do
write(M[i]:4);
writeln;

Усовершенствованный алгоритм сортировки пузырьком:

P:=True; {есть перестановка?}
K:=1; {Номер просмотра}
While P Do
Begin
P:=false;
For i:=1 To n-k Do
If X[i] > X[i+1] Then
Begin
A:=X[i];
X[i]:=X[i+1];
X[i+1]:=A;
P:=true;
End;
k:=k+1;
End;

Perl

for(@out){
for(0..$N-1){
if($out[$_]gt$out[$_+1]){
($out[$_],$out[$_+1])=($out[$_+1],$out[$_]);
}
}
}

Ruby

arr = [5, 20, 3, 11, 1, 17, 3, 12, 8, 10]
swap = true
size = arr.length - 1
while swap
swap = false
for i in 0...size
swap |= arr[i] > arr[i + 1]
arr[i], arr[i+1] = arr[i + 1], arr[i] if arr[i] > arr[i + 1]
end
size -= 1
end
puts arr.join(' ')
# output => 1 3 3 5 8 10 11 12 17 20

Python

def swap(arr, i, j):
arr[i], arr[j] = arr[j], arr[i]

def bubble_sort(arr):
i = len(arr)
while i > 1:
for j in xrange(i - 1):
if arr[j] > arr[j + 1]:
swap(arr, j, j + 1)
i -= 1

VBA

Sub Sort(Mus() As Long)
Dim i As Long, tmp As Long, t As Boolean
t = True
Do While t
t = False
For i = 0 To UBound(Mus()) - 1
If Mus(i) > Mus(i + 1) Then
tmp = Mus(i)
Mus(i) = Mus(i + 1)
Mus(i + 1) = tmp
t = True
End If
Next
Loop
End Sub

PHP

$size = sizeof($arr)-1;
for ($i = $size; $i>=0; $i--) {
for ($j = 0; $j<=($i-1); $j++)
if ($arr[$j]>$arr[$j+1]) {
$k = $arr[$j];
$arr[$j] = $arr[$j+1];
$arr[$j+1] = $k;
}
}

JavaScript

function sortBubble(data) {
var tmp;

for (var i = data.length - 1; i > 0; i--) {
for (var j = 0; j < i; j++) {
if (data[j] > data[j+1]) {
tmp = data[j];
data[j] = data[j+1];
data[j+1] = tmp;
}
}
}
return data;
}

JavaFX

function bubbleSort(seq:Number[]):Number[]{

var sort = seq;
var elem:Number;

for(n in reverse [0..sizeof seq - 2]){
for(i in [0..n] ){
if(sort[i+1] < sort[i] ){
elem = sort[i];
sort[i] = sort[i+1];
sort[i+1] = elem;
}
}
}

return sort;
}

Nemerle

using System.Console;
using Nemerle.Collections;

def arr = array [100, 45, 2, 5, 3, 122, 3, 5, 6, 1, 3];

foreach (i in [0..arr.Length-1])
foreach (j in [0..arr.Length-2])
when (arr[j] > arr[j+1])
(arr[j], arr[j+1]) = (arr[j+1], arr[j]);

WriteLine($"Sorted list is a $(arr.ToList())");

TurboBasic 1.1

CLS
RANDOMIZE TIMER
DEFINT X, Y, N, I, J, D
N = 10 ' 32 766 - 62.7 SEC
DIM Y[N], Y1[N], Y2[N], Y3[N], Y4[N] 'FRE(-1)=21440-21456

PRINT " ZAPOLNENIE MASSIVA ELEMENTAMI"

FOR X = 1 TO N
Y[X] = X
PRINT Y[X];
NEXT X:PRINT

PRINT " PEREMESHIVANIJE ELEMENTOV MASSIVA"

PRINT " SLUCHAINYE CHISLA"

FOR X = 1 TO N
YD=Y[X]
XS=INT(RND*N)+1
PRINT XS;
Y[X]=Y[XS]
Y[XS]=YD
NEXT X:PRINT

PRINT " PEREMESHANNYJ MASSIV"

FOR X=1 TO N
PRINT Y[X];
NEXT X:PRINT

'ALGORITM "SORTIROVKA PROSTYM OBMENOM" O(N^2)
MTIMER
FOR J=1 TO N-1 STEP 1
F=0
FOR I=1 TO N-J STEP 1
'IF Y[I] > Y[I+1] THEN D=Y[I]:Y[I]=Y[I+1]:Y[I+1]=D:F=1
IF Y[I] > Y[I+1] THEN SWAP Y[I],Y[I+1]:F=1

LOCATE 8,1 REM
PRINT " ANYMACIJA SORTIROVKI" REM
FOR X1=1 TO N REM ANIMATION BLOCK
PRINT Y[X1]; REM
NEXT X1:PRINT REM
DELAY .5 REM

NEXT I
IF F=0 THEN EXIT FOR
NEXT J
T1=MTIMER

PRINT " OTSORTIROVANNYJ MASSIV"

FOR X=1 TO N
PRINT Y[X];
NEXT X:PRINT
PRINT "ELAPSED TIME=";T1
�

Категория:

Алгоритмы сортировки

Навигация

Создать учётную запись
Представиться системе

Учебник
Обсуждение

Читать
Правка
История

Заглавная страница
Каталог
Случайная статья

Участие

Справка
Форум
Свежие правки
Новые страницы
Пожертвования

Инструменты
Печать/экспорт
На других языках

English
Italiano

Последнее изменение этой страницы: 11:37, 25 апреля 2013.
Текст доступен по лицензии Creative Commons Attribution/Share-Alike, в отдельных случаях могут действовать дополнительные условия. Подробнее см. Условия использования.

Политика конфиденциальности
Введение
Отказ от ответственности
Мобильная версия

Wikimedia Foundation
Powered by MediaWiki

Implementazioni di algoritmi/Bubble sort
Wikibooks, manuali e libri di testo liberi.
< Implementazioni di algoritmi
Implementazioni di algoritmi

Tutti i moduli ћ Copertina ћ Sviluppo ћ modifica il box

Copertina

Algoritmo di EuclideAvanzamento: 100%
Elevazione a potenzaAvanzamento: 100%
Prodotto scalareAvanzamento: 50%
Calcolo della PasquaAvanzamento: 100%
Metodo Monte CarloAvanzamento: 75%
Ricerca
Ricerca dicotomicaAvanzamento: 100%
Numeri primi
Crivello di EratosteneAvanzamento: 100%
Test di primalità
Test deterministicoAvanzamento: 50%
Test di Miller-RabinAvanzamento: 0%
PRNG
Mersenne TwisterAvanzamento: 75%
Test Chi QuadratoAvanzamento: 75%
Crittografia
RSAAvanzamento: 75%
TEAAvanzamento: 100%
π(Metodi per definire il pi greco)
Pi grecoAvanzamento: 50%
Algoritmi di ordinamento
Bubble sortAvanzamento: 100%
Bucket sortAvanzamento: 100%
Counting sortAvanzamento: 100%
Gnome sortAvanzamento: 100%
Insertion sortAvanzamento: 100%
Merge sortAvanzamento: 100%
QuicksortAvanzamento: 100%
Radix sortAvanzamento: 100%
Selection sortAvanzamento: 100%
Shaker sortAvanzamento: 100%
Shell sortAvanzamento: 100%


Il bubble sort o bubblesort (letteralmente: ordinamento a bolle) è un semplice algoritmo di ordinamento per ordinare array. Non è un algoritmo efficiente: ha una complessità computazionale (misurata in termini di numero di confronti) O(n²-); si usa solamente a scopo didattico in virtù della sua semplicità, e per introdurre i futuri programmatori al ragionamento algoritmico e alle misure di complessità. Dell'algoritmo esistono numerose varianti, per esempio lo shakersort. Come tutti gli algoritmi di ordinamento, può essere usato per ordinare dati di un qualsiasi tipo su cui sia definita una relazione d'ordine; a fini illustrativi, in questo articolo ci riferiremo all'ordinamento di un array di numeri interi.

Il nome dell'algoritmo è dovuto al fatto che, durante l'applicazione del procedimento, i valori vengono spostati all'interno dell'array con una dinamica che ricorda il movimento delle bollicine in un bicchiere di champagne. In particolare, alcuni elementi attraversano l'array velocemente (come bollicine che emergono dal fondo del bicchiere), altri più lentamente (a differenza di quanto avviene nel caso del bicchiere di champagne, tuttavia, alcuni elementi salgono ma altri scendono).
Indice

1 Analisi dell'algoritmo
2 Implementazioni
2.1 C
2.2 Java
2.3 BASIC
2.4 Ruby
2.5 Perl
2.6 Python
2.7 Fortran
2.8 Lisp
2.9 AppleScript
2.10 PHP
3 Altri progetti

Analisi dell'algoritmo

Il bubble sort effettua all'incirca \frac{N^2}{2} confronti ed \frac{N^2}{2} scambi sia in media che nel caso peggiore. Il tempo di esecuzione dell'algoritmo è Θ(n2).
Implementazioni

Seguono alcune implementazioni in vari linguaggi. Le implementazioni nei diversi linguaggi non si riferiscono necessariamente alla stessa variante dell'algoritmo.
C

void BubbleSort(int *array, int elemN)
{
/* elemN è il numero degli elementi del vettore da ordinare */
for (int alto = elemN - 1; alto > 0; alto-- )
{
for (int i=0; i<alto; i++)
{
if (array[i]>array[i+1]) /* sostituire ">" con "<" per avere un ordinamento decrescente */
{
int tmp = array[i];
array[i] = array[i+1];
array[i+1] = tmp;
}
}
}
}

tmp è dichiarata di tipo int, quindi dovrà contenere interi; se l'array contiene elementi di tipo diverso, sarà sufficiente modificare la sua dichiarazione.
Java

public void bubbleSort(int[] x)
{
int temp = 0;
int j = x.length-1;
while(j>0)
{
for(int i=0; i<j; i++)
{
if(x[i]>x[i+1]) //scambiare il '>' con '<' per ottenere un ordinamento decrescente
{
temp=x[i];
x[i]=x[i+1];
x[i+1]=temp;
}
}
j--;
}
}

Implementazione dell'algoritmo che presenta le ottimizzazioni enunciate alla voce Bubble sort:

void bubbleSort (int[] a){
boolean swapped=true;
int n=a.length-1;
int limit=0;
int temp=0;
while (swapped && n>0){
swapped=false;
for (int i=0;i<n;i++){
if (a[i]>a[i+1]){ //scambiare il '>' con '<' per ottenere un ordinamento decrescente
temp=a[i];
a[i]=a[i+1];
a[i+1]=temp;
swapped=true;
limit=i;
}
}
n=limit;
}
}

Algoritmo implementato sui vector, in questo esempio, di oggetti di tipo String:

public void bubbleSort(Vector v)
{
String first;
String next;
int i = v.size();
while(i>0)
{
for(int j=0; j < i; j++)
{
first = (String) v.elementAt(j);
next = (String) v.elementAt(j+1);
if(first.compareTo(next)>0) /*scambiare il '>' con '<' per ottenere un ordinamento decrescente*/
exchange(v,j,j+1);
}
i--;
}
}

public static void exchange(Vector v, int i, int j)
{
Object obk = v.elementAt(i);
v.setElementAt(v.elementAt(j),i);
v.setElementAt(obk,j);
}

Segue una documentata implementazione Java dell'algoritmo di sort a bolle,
pensata da uno studente del dipartimento di informatica (ITPS) di Bari:

/**
* Questo algoritmo di sort a bolle, si basa sul
* confronto, passo dopo passo, dell'elemento corrente (dell' indice)
* con quello precedente (confronto tra coppie adiacenti).
* Se quello precedente e' maggiore di quello corrente
* viene effettuato lo scambio.
*
* Descrizione dettagliata:
* La variabile passo corrisponde al passo corrente, ovvero al numero
* di elementi gia' ordinati.
* Se nel passo sono stati effettuati scambi (lo sappiamo grazie alla
* variabile booleana scambio) allora significa che l'array non e' ancora
* ordinato e quindi bisogna continuare con il prossimo passo.
* Se, invece, in un intero passo non sono stati effettuati scambi (nel
* ciclo interno do-while) allora l'array e' ordinato e quindi si puo'
* uscire dall' intero algoritmo.
* Cosi' facendo si riesce a far risalire a galla ordinatamente le
* stringhe più' piccole fra quelle in esame.
* Ho pensato ad un ciclo do-while e non un while, perché
* altrimenti l'ultimo elemento (quello la cui posizione e' maggiore
* del passo) non verrebbe ordinato.
* Nel caso peggiore si esce dall'algoritmo solo quando il passo supera
* la posizione dell'ultimo elemento dell'array, e questo si verifica
* ad esempio quando gli elementi da ordinare sono in un ordine inverso.
* L'ordine di complessita' e' quadratico [MAX (n)*(n-1)/2 ],
* ma l'algoritmo, grazie alla variabile sentinella scambio,
* risulta ottimizzato.
*/

public void sort() {
String temp = "";
String[] strings = {"ciao", "come", "stai"};
int indice = 0;
//variabile sentinella di scambio.
boolean scambio = true;
if (strings.length > 1) {
//Il ciclo esterno si occupa di incrementare il passo se, e solo se,
//il passo corrente e' minore del numero di stringhe presenti nell'
//array e se sono stati effettuati scambi nel passo precedete.
for (int passo = 0; passo <= (strings.length - 1)
&& (scambio); passo++) {
//impostiamo indice all'utlimo elemento presente nell'array.
indice = strings.length - 1;
scambio = false;
do {
if (strings[indice].compareToIgnoreCase(
strings[indice - 1]) < 0) {
temp = strings[indice];
strings[indice] = this.strings[indice - 1];
strings[indice - 1] = temp;
//Sono stati effettuati scambi,quindi scambio sara'true.
scambio = true;
}
indice--;
} while (indice > passo);
//Non e'difficile notare che mentre il passo aumenta da sinistra,
//da destra vengono man mano ordinati sempre meno elementi.
}
}
}

BASIC

Sub BubbleSort(ByRef MioArray() As Integer)
Dim I, J, Temp As Integer
For I = UBound(MioArray, 1) To LBound(MioArray, 1) Step -1
For J = LBound(MioArray, 1) To I - 1
If MioArray(J) > MioArray(J + 1) Then 'scambiare il ">" con "<" per ottenere un ordinamento decrescente
Temp = MioArray(J)
MioArray(J) = MioArray(J + 1)
MioArray(J + 1) = Temp
End If
Next J
Next I
End Sub
''MioArray'' e ''tmp'' sono dichiarati di tipo ''Integer'', quindi dovranno contenere interi; se l'array contiene elementi di tipo diverso, sarà sufficiente modificare le dichiarazioni di entrambi.

Ruby

def bubble(v)
tmp=v.length

while tmp > 0
(tmp-1).times{|i|
if v[i] > v[i+1]
v[i] , v[i+1] = v[i+1] , v[i] #scambia v[i] con v[i+1] alla maniera del Ruby!
end
}
tmp-=1
end
end

Perl

sub bubble_sort(@) {
my @a = @_;
foreach $i (reverse 0..$#a) {
foreach $j (0..$i-1) {
($a[$j],$a[$j+1]) = ($a[$j+1],$a[$j]) if ($a[$j] > $a[$j+1]);
}
}
return @a;
}

Python

def bubblesort(iterable):
seq = list(iterable)
for passesLeft in xrange(len(seq)-1, 0, -1):
for index in xrange(passesLeft):
if seq[index] > seq[index + 1]:
seq[index], seq[index + 1] = seq[index + 1], seq[index]
return seq

Fortran

SUBROUTINE Bubble (X,N)
! X e' l'array da ordinare in modo non decrescente, di estensione N
IMPLICIT NONE
INTEGER :: N, J, I, TEMP
INTEGER :: X(N)
spike1: DO I=1,N
spike2: DO J=1,N-1
IF(X(J)<X(J+1)) CYCLE
TEMP=X(J)
X(J)=X(J+1)
X(J+1)=TEMP
END DO spike2
END DO spike1
RETURN
END
! GO TO [label] è un'istruzione deprecata da FORTRAN77 e condannata dal Th. di Böhm-Jacopini.

Lisp

(DEFUN bubble-sort (X)
(LET ((Bubble (bubble X)))
(IF (EQUAL X Bubble) X (bubble-sort Bubble))))

(DEFUN bubble (X)
(COND ((NULL X) X)
((= (LENGTH X) 1) X)
((LISTP X)
(IF (> (CADR X) (CAR X))
(CONS (CADR X)
(bubble (CONS (CAR X) (CDDR X))))
(CONS (CAR X) (bubble (CDR X)))))
(T (ERROR "bubble expects a list"))))

AppleScript

on bubblesort( array )
repeat with i from 1 to length of array
repeat with j from 1 to length of array - 1
tell array
if item j > item ( j + 1 ) then
set { item j, item ( j + 1 ) } to { item ( j + 1 ), item j }
end if
end tell
end repeat
end repeat
end bubblesort

Nota: AppleScript è 1-based, cioè il primo elemento di una lista è 1
PHP

function bubbleSort ($array)
{
$alto= count ($array);

while ($alto > 1) /* in questo modo si evita 1 passaggio*/
{
for ($i = 0; $i < $alto - 1; $i++)
if ($array[$i] < $array[$i+1]) /* sostituire ">" con "<" per avere un ordinamento decrescente */
{
$tmp = $array[$i];
$array[$i] = $array[$i+1];
$array[$i+1] = $tmp;
}
$alto--;
}
}

Altri progetti

Collabora a Wikipedia Wikipedia contiene una voce riguardante questo algoritmo

Categorie:

Moduli 100%
Implementazioni di algoritmi

Menu di navigazione

Crea un'utenza
Entra

Modulo 100%
Discussione

Leggi
Modifica
Cronologia

Pagina principale
Biblioteca
Vetrina
Ultime modifiche
Una pagina a caso
Un libro a caso

Comunità

Portale comunità
il Wikibookiano
Bar
Aiuto
Donazioni
Contatti

Stampa/esporta
Strumenti
Altri progetti
In altre lingue

English

Questa pagina è stata modificata per l'ultima volta il 18 apr 2013 alle 12:39.
Il testo è disponibile secondo la licenza Creative Commons Attribuzione-Condividi allo stesso modo; possono applicarsi condizioni ulteriori. Vedi le condizioni d'uso per i dettagli.

Privacy
Informazioni su Wikibooks
Avvertenze
Versione mobile

Wikimedia Foundation
Powered by MediaWiki



[Сообщение изменено пользователем 04.05.2013 12:46]

Уно, уно тильки джава.... :mad:

Это что тут было? :confused:

у нас в потоке их практически не было, например. во всяком случае, я не обращала внимание на какое-то особое их наличие.


на кой хрен это здесь? :ultra:
ОН - не форум для начинающих программистов.

Экзампл пызырька итальяно. Весьма распространённый алгоритм в студенческой среде... Просто трудно студентам рассказывать - "давным-давно, на ранних этапах,.... алгоритмы сортировки, метод пызирька, Тихий час, дети! " :lol:

У Серёги на одной клавиатуре контрол-В заклинило, на другой контрол-С, а мышка от ужаса спряталась под диван 8(
ПЫСЫ У мну крутой скрипт есть из двух строчек вбс-ных, как работает не знаю - но работает, лень диск подключать.... :beach:

А это что было.. 8(

зеленый надо включать. цвет луны.

8(

Оно самое... Пока объянссишь - что это - батон чая выпить можно...
Код Pascal

uses crt;
type massiv=array [1..5000] of integer;
var
x:massiv;
i,n:integer;
procedure sort(l,r:integer);
var
i,j,x1,y1,m: integer;
begin
i:=l;
j:=r;
m:=round ((l+r)/2);
x1:=x[m];
repeat
while x[i]<x1 do inc(i);
while x[j]>x1 do dec(j);
if i<=j then
begin
y1:=x[i];
x[i]:=x[j];
x[j]:=y1;
inc(i);
dec(j);
end;
until i>j;
if l<j then sort(l,j);
if i<r then sort(i,r);
end;

begin
clrscr;
randomize;
write('Введите размер массива не более 5000 n=');
readln(n);
writeln('Исходный массив:');
for i:=1 to n do
begin
x[i]:=random(50)-10;
write(x[i],' ');
end;
writeln;
sort(n,1);
writeln('Массив после сортировки: ');
for i:=1 to n do
write(x[i],' ');
readln;
end.

:weep:

[Сообщение изменено пользователем 04.05.2013 13:17]