Aktywne Wpisy
MaxHamilton +15
Chciałbym urodzić się na nowo ale w latach 00s (im później tym lepiej). Teraz dzieciaki mają ekstra, bezstresowe wychowanie, rodzice pracownicy korpo, na wszystko ich stać, mają jakiś start. O wiele więcej możliwości, nawet w przedszkolu są zajęcia z programowania, urodzili się w czasach internetu i widzą że można wszystko. Zero ograniczeń, zero PRL-owskiego wychowania, ich rówieśnicy studiują sobie za granicą, podróżują sobie po świecie. Nawet mogą robić głupkowaty content na youtube
alverini +155
najwieksza beka jest z Paszy xD gość dostał się do Virtusów po znajomości po pijaku od znajomego szwagra (to jest akurat fakt autentyczny) a z racji że nic nie umiał no to yyyy będziesz stał z tyłu z awp i nam nie przeszkadzał xD #!$%@? że to przed Neo znało CSa w ogóle 14 osób w polsce xD łatwa fucha i nikt ci nic nie wypomni bo nikt się nie zna xD
Dobra załóżmy, że mam wektor intów i chce go posortować, jak to zrobić ładnie? Ale żeby zera były na końcu?
Niby mogę zrobić sort i później jakoś wyłuskać te zera i przerzucić na koniec, ale nie wydaje mi się to optymalne ;/ A operatora porwania nie da rady napisać, żeby sorta oszukać...
EDIT: tak mi szybko przyszło do głowy.
Ja bym na szybko policzyl zera i usunal je z wektora, potem posortowal wektor i dodal zera na koniec :>
void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);
a to compare jak byś własne zrobił
vector<int```**```
> a{1,-2,3,-4,0,0,0};
``````
sort(begin(a),end(a),[](
```**```
int
```**```
l,
```**```
int
```**```
r){
```**```
return
```**```
abs(l) > abs(r); } );
@sw69: No jak to nie? Nie mniej jednak, lepiej tego nie robić. Odpowiednia byłaby własna funkcja sortująca. A quicksort zawsze jest najlepszy, chyba że masz jakieś bardzo niestandardowe dane (na przykład prawie posortowane).
bool compare(int a, int b) {
return (a != 0)? (a < b) : false;
}
sort(vector.begin(), vector.end(), compare);
Ta funkcja compare zwraca, czy a jest mniejsze od b
if (a * b == 0) {
return (a == 0) ? false : true;
} else
return a < b; }
);
5,4,2,1,0
czy też zwykłe z zerami na końcu:
1,2,3,4,5,0,0,0
return (a != 0)? (a < b) : false;
}
@Onoki: To była moja pierwsza myśl, żeby zrobić coś takiego. Ale to oczywiście nie działa, bo funkcja jest niepoprawna dla nieliniowego porównania. Owszem, jeżeli b byłby zawsze następnym elementem to tak, ale inaczej... Zresztą wywala assert, że funkcja porównująca jest niepoprawna.
@deekox: Dzięki, właśnie po chwili zastanowienia miałem spróbować sprawdzać a i b :)
A spróbuj
return (a != 0 && b != 0)? (a < b) : (a > b);
Zwraca mniejszy element jeżeli oba są niezerowe, większy (w szczególności niezerowy) w przeciwnym razie. :) W tamtym poprzednim zapomniałem, że b może też być zerem.
@Onoki: nie działa dla liczb ujemnych :P
Dlatego: http://ideone.com/H10GCf
Tak więc bazując na Twojej propozycje zrobiłem tak i za chwilę przetestuje, ale powinno być ok.
return (a.GetOrgNumber() == 0 && b.GetOrgNumber() == 0) ? less()(a.GetNumber(), b.GetNumber()) : (a.GetOrgNumber() == 0 || b.GetOrgNumber() == 0) ? b.GetOrgNumber() == 0 : less()(a.GetOrgNumber(), b.GetOrgNumber());Ps. W tym przypadku już nie muszę mieć XORa, bo i tak wcześniej
int```**```
l = a.GetOrgNumber();
```**```
int
```**```
r = b.GetOrgNumber();
```**```
return
```**```
(l == 0) ^ (r == 0) ? r == 0 : l < r;
false, to wynik tego porównania zawsze taki sam jest.
int```**```
l = a.GetOrgNumber();
```**```
int
```**```
r = b.GetOrgNumber();
```**```
return
```**```
(l == 0 && r == 0) ?
```**```
false
```**```
: (l == 0 || r == 0) ? r == 0 : l < r;
a.GetNumber();
a.GetOrgNumber();