Boshqalarni hisobga olmasdan n-th joyni topish

Permut atomlarini ifodalovchi N elementlarining bir qatorini nazarda tutgan holda, shunday algoritm mavjud:

function getNthPermutation( $atoms, $permutation_index, $size )

bu erda $ atoms elementlarning qatori, $ permutation_index - permutation indekslari va $ size - permutationning o'lchami.

Masalan:

$atoms = array( 'A', 'B', 'C' );
// getting third permutation of 2 elements
$perm = getNthPermutation( $atoms, 3, 2 );

echo implode( ', ', $perm )."\n";

Chop etish:

B, A

$ Permutation_indexgacha har bir permutationni hisoblashsizmi?

Fandaydaydiy almashtirishlar haqida biror narsa eshitdim, ammo topdimki, har qanday amalga oshirilgan ish natijasi mening Vaziyat emas, balki bir xil o'lchamdagi Vga ega.

Rahmat.

36
N-elementlarning har bir almashinishini uning iteratsiya hisoblagichi bilan chop etishingizni tasavvur qiling (permutation 0, permutation 1, permutation 2, ...) ... n-th permutatsiyani istayman.
qo'shib qo'ydi muallif Simone Margaritelli, manba
menda almashtirishlar haqida qayg'urmasam, har qanday ishni bajaraman :)
qo'shib qo'ydi muallif Simone Margaritelli, manba
Buyurtma haqida qayg'urmasangiz, siz xohlagan kattalikdagi $ hajmini tanlang. bu funksiyani har xil ko'rsatkich bilan har safar bir necha marta chaqirishni xohlaysizmi?
qo'shib qo'ydi muallif galchen, manba
ammo joylashtirish tartibi nimani belgilaydi? Ya'ni, indeks 0 bilan almashinish shakllarning har qanday bo'lishi mumkin
qo'shib qo'ydi muallif galchen, manba
Sizning nomingizdagi indeksni nima demoqchisiz?
qo'shib qo'ydi muallif galchen, manba

7 javoblar

RickyBobby ta'kidlaganidek, permyatsiyalarning leksikografiya tartibini ko'rib chiqayotganda, faktoriy dekompozitsiyani sizning afzalligingizdan foydalaning.

Amaliy nuqtai nazardan qaraganda, buni quyidagicha tushunaman:

  • (n-1)! , (n-2)! bilan boshlangan faktik raqamlar bilan amalga oshiring. .
  • Qatorlarni bir qatorda saqlang. i - bu turkum kod 0 va ni-1 o'rtasida bo'lishi kerak, n-1 kodini kiriting.
  • qatori sizning joylashuvingiz. Muammo shundaki, har bir element avvalgi qadriyatlarga umuman e'tibor bermaydi, shuning uchun siz ularni sozlashingiz kerak. Keyinchalik ochiq, har bir qadriyatni ko'paytirish kerak, chunki oldingi qiymatlar past yoki tengdir.

Quyidagi kod C kodi sizga bu qanday ishlashi haqida ma'lumot berishi kerak ( n - yozuvlarning soni va i - permutation indeksidir):

/**
 * @param n The number of entries
 * @param i The index of the permutation
 */
void ithPermutation(const int n, int i)
{
   int j, k = 0;
   int *fact = (int *)calloc(n, sizeof(int));
   int *perm = (int *)calloc(n, sizeof(int));

  //compute factorial numbers
   fact[k] = 1;
   while (++k < n)
      fact[k] = fact[k - 1] * k;

  //compute factorial code
   for (k = 0; k < n; ++k)
   {
      perm[k] = i/fact[n - 1 - k];
      i = i % fact[n - 1 - k];
   }

  //readjust values to obtain the permutation
  //start from the end and check if preceding values are lower
   for (k = n - 1; k > 0; --k)
      for (j = k - 1; j >= 0; --j)
         if (perm[j] <= perm[k])
            perm[k]++;

  //print permutation
   for (k = 0; k < n; ++k)
      printf("%d ", perm[k]);
   printf("\n");

   free(fact);
   free(perm);
}

Misol uchun, ithPermutation (10, 3628799) , kutilgandek, o'nta elementlarning oxirgi joylashuvi:

9 8 7 6 5 4 3 2 1 0
41
qo'shib qo'ydi
+1 thx Feliksni amalga oshirish uchun :)
qo'shib qo'ydi muallif Ricky Bobby, manba
Bu men uchun izlanayotgan dastur bo'lib, "n" argumenti kalit ... thanks soooo much :)
qo'shib qo'ydi muallif Simone Margaritelli, manba
Factadic/lexmer kodini olish uchun ishlatiladigan usul (hisoblangan faktorlardan foydalanadi va qoldiqlarni saqlamaydi) Wikipedia sahifasining Vikipediya sahifasidan farq qiladi: https://en.wikipedia.org/wiki/Factorial_number_system "rel =" nofollow noreferrer "> Factoradic dan faqat bir oz yuqoriroq misollar bo'limiga qarang. Viktorina qilingan chiqim bir xil bo'lsa-da, men keyingi uslubni osonroq topaman. Shunga qaramay sizning namunangiz menga kontseptsiyani yaxshiroq tushunishimga yordam berdi.
qo'shib qo'ydi muallif konsolebox, manba

Bu yerda permutation hajmini tanlashga imkon beruvchi yechim mavjud. Misol uchun, 10 ta elementlarning barcha permütasyonlarını yaratabilmekle bilan birga, 10 element orasida juftlikning permütasyonlarını mumkin. Bundan tashqari, faqat tamsayılar emas, balki o'zboshimchalikli narsalar ro'yxatini kiritadi.

Bu PHP, lekin JavaScript va Haskell amalga oshirilishi.

function nth_permutation($atoms, $index, $size) {
    for ($i = 0; $i < $size; $i++) {
        $item = $index % count($atoms);
        $index = floor($index/count($atoms));
        $result[] = $atoms[$item];
        array_splice($atoms, $item, 1);
    }
    return $result;
}

Foydalanish misoli:

for ($i = 0; $i < 6; $i++) {
    print_r(nth_permutation(['A', 'B', 'C'], $i, 2));
}
// => AB, BA, CA, AC, BC, CB

Qanday ishlaydi?

Buning orqasida juda qiziq bir fikr bor. A, B, C, D ro'yxatini olamiz. Biz kartalarning pastki qismidan elementlarni chizish yo'li bilan almashtirish mumkin. Dastlab biz to'rtta elementdan birini chizamiz. Keyin qolgan uchta elementdan biri, va hokazo, nihoyat, hech narsa qolmadi.

Decision tree for permutations of 4 elements

Bu variantlardan biri bo'lishi mumkin. Yuqoridan boshlab biz uchinchi yo'lni egallayapmiz, keyin birinchi, ikkinchi va nihoyat birinchi. Bu bizning joylashuvimiz.

Tanlash tartibini hisobga olgan holda, siz o'n to'qqizta algoritmik usulga ega bo'lasiz. So'ngra algoritmingizni qaytarib oling va ketma-ketlikni butun sondan qayta tiklashingiz mumkin.

Keling, ketma-ketliklarni to'plash uchun umumiy sxemani topib, ortiqcha holda butun songa kiritamiz va uni qayta ochamiz.

Qiziqarli sxema - o'nlik raqamli tizim. "27" ni 10-sonli 2-sonli yo'lni tanlash va 10-sonning 7-sonli yo'lini tanlab olish deb hisoblash mumkin.

Decision three for number 27 in decimal

Lekin har bir raqam faqat 10 variantdan birini tanlashi mumkin. Ikki tomonlama va o'n oltinchi sonli kabi qattiq radixlarga ega bo'lgan boshqa tizimlar, shuningdek, faqat bir qator muqobil variantlardan birini tanlashi mumkin. Biz "14:05:29" 14 soatdan 14 soatga, soatiga 5-daqiqada 5-daqiqada, 60-dan 29-daqiqada.

Agar umumiy raqam-to-string va string-to-number funksiyalarini qabul qilsak va ularni aralash radixlardan foydalanishga aldansak nima bo'ladi? parseInt («beef») kabi bitta radixani olish o'rniga, , 16) va (48879) .toString (16) , ular har bir raqam uchun bitta radix oladi.

function pack(digits, radixes) {
    var n = 0;
    for (var i = 0; i < digits.length; i++) {
        n = n * radixes[i] + digits[i];
    }
    return n;
}

function unpack(n, radixes) {
    var digits = [];
    for (var i = radixes.length - 1; i >= 0; i--) {
        digits.unshift(n % radixes[i]);
        n = Math.floor(n/radixes[i]);
    }
    return digits;
}

Bu ham ishmi?

// Decimal system
pack([4, 2], [10, 10]);//=> 42

// Binary system
pack([1, 0, 1, 0, 1, 0], [2, 2, 2, 2, 2, 2]);//=> 42

// Factorial system
pack([1, 3, 0, 0, 0], [5, 4, 3, 2, 1]);//=> 42

Va endi orqaga:

unpack(42, [10, 10]);//=> [4, 2]

unpack(42, [5, 4, 3, 2, 1]);//=> [1, 3, 0, 0, 0]

Bu juda chiroyli. Keling, ushbu parametrik raqam tizimini permutatsiyalar muammosiga qo'llaylik. A, B, C, D ning uzunlikdagi 2 joylashuvini ko'rib chiqamiz. Ularning umumiy soni nima? Keling, ko'rib chiqaylik: avval 4 ta elementdan birini chiqaramiz, qolganlari 3dan biri, ya'ni 4 * 3 = 12 2 ta elementni chizish usullari. Ushbu 12 ta usul tamsaytlarga joylashtirilishi mumkin [0..11]. Xullas, ularni allaqachon to'ldirib qo'yaylik va ochishni o'ylab ko'ring:

for (var i = 0; i < 12; i++) {
    console.log(unpack(i, [4, 3]));
}

// [0, 0], [0, 1], [0, 2],
// [1, 0], [1, 1], [1, 2],
// [2, 0], [2, 1], [2, 2],
// [3, 0], [3, 1], [3, 2]

Bu raqamlar asl majmuadagi indekslarni emas, tanlovlarni ifodalaydi. [0, 0] kodi A, B, C, D dan (u A), keyin esa # Qolgan qismi B, C, D (u B). Va natijada joylashgan A, B .

Boshqa bir misol: [3, 2] kodi A, B, C, D dan (u D) 3-bandni va undan keyin A, B, C (bu C). Natijada joylashgan D, C .

Ushbu xaritalashga Lehmer kodi deb nom berilgan. Ushbu Lehmer kodlarining barchasini almashtiramiz:

AB, AC, AD, BA, BC, BD, CA, CB, CD, DA, DB, DC

Bizga kerak bo'lgan narsa shu. Agar siz unpack funktsiyasiga qaratsangiz, o'ngdan chapga raqamlar ( pack harakatlarini teskari o'zgartirish uchun) ishlab chiqarilganini ko'rasiz. Tanlov 3 dan 4-chi variantga qadar paketdan chiqarib yuboriladi. Buning sababi shundaki, biz tanlagangacha 4 ta elementdan birini tanlashni istaymiz. Buning uchun avvalo Lehmer kodini hisoblashimiz kerak, uni vaqtinchalik qatorga to'plashimiz kerak, va keyin uni haqiqiy almashtirishni hisoblash uchun ob'ektlar majmuasiga qo'llang.

Agar biz leksikografiya tartibiga umuman e'tibor bermasak, biz 4 elementni tanlashdan oldin 3 ta elementdan birini tanlashni xohlaymiz, deyishimiz mumkin. So'ng 4dan tanlov unpack dan chiqadi. Boshqacha aytganda unpack (n, [4, 3]) o'rniga unpack (n, [3, 4]) dan foydalanamiz. Ushbu dastur Lehmer kodining keyingi sonini hisoblab chiqadi va darhol ro'yxatga kiritadi. Va shuni aniqki nth_permutation() ishlaydi.

Eslatib o'tmoqchimanki, unpack (i, [4, 3]) factorial raqamli tizim bilan chambarchas bog'liq. Uzunlik 2 ning takroriy nusxasidek almashtirishini istasak, bu birinchi daraxtga yana bir nazar sol, biz har bir ikkinchi permütasyon indeksini atlayabiliriz. Bu bizga 12 uzunlikdagi uzunlikdagi 4 ta uzunlikni almashtirish imkonini beradi.

for (var i = 0; i < 12; i++) {
    var lehmer = unpack(i * 2, [4, 3, 2, 1]);//Factorial number system
    console.log(lehmer.slice(0, 2));
}
25
qo'shib qo'ydi

Sizning almashtirishlaringizni (masalan, leksikografiya tartibini) "tartiblashtirish" ga bog'liq.

Buning bir usuli factorial raqamlar tizimi , sizga [0, n!] va barcha permütasyonlar.

Keyin [0, n!] Idagi har qanday son uchun boshqalarni hisoblashdan o'zingizni almashtirishni hisoblashingiz mumkin.

Ushbu faktorial yozuv, [0 va n!] O'rtasidagi har qanday sonni quyidagicha yozish mumkinligiga asoslanadi:

SUM( ai.(i!) for i in range [0,n-1]) where ai 

(bu bazaga ajralib ketishga juda o'xshaydi)

for more information on this decomposition, have a look at this thread : https://math.stackexchange.com/questions/53262/factorial-decomposition-of-integers

U yordam beradi deb umid qilaman


Ushbu wikipedia maqolasida aytilganidek, bu yondashish lexmer kodi :

N'nin permütasyonlarını yaratish uchun aniq bir yo'l qadriyatlarni yaratishdir   Lehmer kodi (ehtimol factorial raqam tizimidan foydalaniladi   tamsayıların n'ye qadar naql bo'lishi) va ularni   tegishli permütasyonlar. Biroq, keyingi qadam   juda sodda va samarali amalga oshirish qiyin, chunki u talab qiladi   n tanlovning har birini ketma-ketlikdan o'chiradi va undan o'chiriladi,   tasodifiy pozitsiyada; aniq namoyishlar   qator yoki bog'langan ro'yxat sifatida ketma-ketlik, ikkinchisi (turli xil)   sabablari) n2/4 operatsiyalari bo'yicha ishlashni amalga oshirish. N bilan   ehtimol kichik bo'lishi mumkin (ayniqsa, barcha avlod bo'lsa)   permütasyonlar kerak), bu juda ko'p muammo emas, balki   tasodifiy va sistematik avlodlar uchun ham mavjud   ancha yaxshi bo'lgan oddiy alternativlar. Shuning uchun bu   har qanday bo'lishi mumkin bo'lsa-da, maxsus ish qilish foydali emas   Lehmerdan ishlashni amalga oshirish imkonini beradigan ma'lumotlar strukturasi   (N log n) vaqtidagi almashtirish kodi.

Shunday qilib, n elementining to'plamida bajarishingiz mumkin bo'lgan eng yaxshi narsa O (n ln (n)), moslashtirilgan ma'lumotlar tuzilmasi bilan.

14
qo'shib qo'ydi
@SimoneMargaritelli nimani nazarda tutasiz? siz dastlabki elementlar to'plamingizning bir to'plamini almashtirishni xohlaysizmi?
qo'shib qo'ydi muallif Ricky Bobby, manba
Men faktorial sonlar tizimidan allaqachon xabardor bo'lganman, lekin mahsulotni dastlabki vektorlari bilan bir xil emas, ammo ishlab chiqarishni joylashtirish hajmini o'zgartira olmayman.
qo'shib qo'ydi muallif Simone Margaritelli, manba
Albatta, U (ng lg U) vEB daraxtlarini ishlatishingiz mumkin, chunki U = n. Afsuski pastki chegara nima?
qo'shib qo'ydi muallif dhruvbird, manba

O'zgartirishlar va safarlar oralig'ida lineer vaqtda almashtirish uchun algoritm mavjud. Ammo, u foydalangan tartibida leksikografik emas. Bu g'alati, ammo izchil. Men ikkita funktsiyani taqdim etmoqchiman: bir martabadan boshlab bir pozitsiyaga aylantiradigan va teskarisini qiladi.

Birinchidan, asabiylashish (toifadan joyga o'tish)

Initialize:
n = length(permutation)
r = desired rank
p = identity permutation of n elements [0, 1, ..., n]

unrank(n, r, p)
  if n > 0 then
    swap(p[n-1], p[r mod n])
    unrank(n-1, floor(r/n), p)
  fi
end

Keyin navbat bilan:

Initialize:
p = input permutation
q = inverse input permutation (in linear time, q[p[i]] = i for 0 <= i < n)
n = length(p)

rank(n, p, q)
  if n=1 then return 0 fi
  s = p[n-1]
  swap(p[n-1], p[q[n-1]])
  swap(q[s], q[n-1])
  return s + n * rank(n-1, p, q)
end

Ularning ikkalasining ish vaqti O (n) dir.

There's a nice, readable paper explaining why this works: Ranking & Unranking Permutations in Linear Time, by Myrvold & Ruskey, Information Processing Letters Volume 79, Issue 6, 30 September 2001, Pages 281–284.

http://webhome.cs.uvic.ca/~ruskey/Publications/RankPerm/MyrvoldRuskey. pdf

7
qo'shib qo'ydi
Ushbu echim, ehtimol, eng tezkor bo'ladi, chunki siz bir qator biriktirma (yoki elementni o'chirish) ni amalga oshirishingiz shart emas va +1 uchun birikmalar yo'q.
qo'shib qo'ydi muallif James, manba

Pythonda elementlarning har bir elementi uchun ishlaydigan qisqa va juda tez (elementlarning sonida linear) eritma (pastdagi misoldagi 13 ta birinchi harf):

from math import factorial

def nthPerm(n,elems):#with n from 0
    if(len(elems) == 1):
        return elems[0]
    sizeGroup = factorial(len(elems)-1)
    q,r = divmod(n,sizeGroup)
    v = elems[q]
    elems.remove(v)
    return v + ", " + ithPerm(r,elems)

Misollar:

letters = ['a','b','c','d','e','f','g','h','i','j','k','l','m']

ithPerm(0,letters[:])          #--> a, b, c, d, e, f, g, h, i, j, k, l, m
ithPerm(4,letters[:])          #--> a, b, c, d, e, f, g, h, i, j, m, k, l
ithPerm(3587542868,letters[:]) #--> h, f, l, i, c, k, a, e, g, m, d, b, j

Eslatma: funktsiya elems parametrini o'zgartirganligi sababli, harflari [:] ( harflari nusxasi)

4
qo'shib qo'ydi
Ro'yxatda ikki nusxadagi chars bo'lsa, nima yuz berdi? Noto'g'ri natija chiqmoqda.
qo'shib qo'ydi muallif Sonu Kumar, manba

Agar siz barcha o'zgarishlarni xotirada saqlasangiz, masalan, qatorda, ularni (1) vaqtning o'zida birma-bir qaytarib olishingiz kerak.

Bu sizning barcha permütasyonlarınızı saqlash kerak degan ma'noni anglatadi, shuning uchun barcha permütasyonları hisoblash taqiqlangan uzoq vaqt oladi, yoki ularni saqlash taqiqlangan katta bo'shliq bo'lsa, u holda bu hal bo'lmasligi mumkin.

Mening taklifim baribir uni sinab ko'rish va agar u juda katta/sekin bo'lsa, qaytib kelishi kerak. Agar naif bir kishi ishni qilsa, "aqlli" echimni qidiradi.

1
qo'shib qo'ydi
OK, sen haqsan, eshitishni xohlaysanmi? :) Bu noto'g'ri tushunish edi, oson dude qabul qilish;)
qo'shib qo'ydi muallif Simone Margaritelli, manba
Men "... har bir permurnatni hisoblashmasdan" ...
qo'shib qo'ydi muallif Simone Margaritelli, manba
Agar men buni oldindan joylashtirilgan permütatsiyalar bilan sinab ko'rganim sababli so'rasam ...
qo'shib qo'ydi muallif Simone Margaritelli, manba
Qarshilik qila olmaydi. Precompted permutatsiyalardan foydalanuvchi algoritm hech qanday o'zgarishlarni hisoblab chiqmaydi. (Men bu savolni va boshqa javoblarni foydali deb bilganim uchungina bu erda bo'laman).
qo'shib qo'ydi muallif dansalmo, manba
Simonni so'ragan savoliga javob bermaslik uchun +1, lekin u so'ragan savolga javob berdi.
qo'shib qo'ydi muallif Patrick87, manba
Kechirasiz, mening ruhiy kuchlarim bugungi kunda meni buzib tashlashi kerak, yoki siz bu ma'lumotni juda kichik matnga qo'yasiz.
qo'shib qo'ydi muallif Chris Browne, manba
Siz, "$ permutation_index" ga qadar, "har bir permurnatni hisoblashsiz" bir xil emas, "har bir permutationni hisoblashsiz" deb yozgan edingiz. Men bu erda birinchi marta o'zlari kontekstdan hech kimni ko'rmadim!
qo'shib qo'ydi muallif Chris Browne, manba
Aha, sen meni eski "xotirjamlik" fokusidan foydalanib, qilding. Men yozgan har qanday javob g'azablanadi, bu mening obro'yimga salbiy ta'sir ko'rsatishi mumkin! Hechqisi yo'q, men "g'alaba qozonish uchun dalillarni" qo'zg'amasligim kerak.
qo'shib qo'ydi muallif Chris Browne, manba
Bu ikki yoshli javob, bu savolga berilgan boshqa javoblar juda qoniqarli, shuning uchun o'zimni tahrir qilishning hojati yo'qligini bilaman (agar biror narsa bo'lsa, uni yo'q qilishni istayman). Sorgulanmaya bo'lgan munosabatim, bu kunlar uchun juda ham kamtar va kechirimli bo'lardi. O'ylaymanki, 2011 yil 27-oktabrda yomon kun bo'ldim.
qo'shib qo'ydi muallif Chris Browne, manba

Bu hisoblanishi mumkin. Bu siz uchun bajaradigan C# kodidir.

using System;
using System.Collections.Generic;

namespace WpfPermutations
{
    public class PermutationOuelletLexico3
    {
       //************************************************************************
        private T[] _sortedValues;

        private bool[] _valueUsed;

        public readonly long MaxIndex;//long to support 20! or less 

       //************************************************************************
        public PermutationOuelletLexico3(T[] sortedValues)
        {
            if (sortedValues.Length <= 0)
            {
                throw new ArgumentException("sortedValues.Lenght should be greater than 0");
            }

            _sortedValues = sortedValues;
            Result = new T[_sortedValues.Length];
            _valueUsed = new bool[_sortedValues.Length];

            MaxIndex = Factorial.GetFactorial(_sortedValues.Length);
        }

       //************************************************************************
        public T[] Result { get; private set; }

       //************************************************************************
        /// 
/// Return the permutation relative to the index received, according to /// _sortedValues. /// Sort Index is 0 based and should be less than MaxIndex. Otherwise you get an exception. ///
 
        /// 
        /// 
Value is not used as inpu, only as output. Re-use buffer in order to save memory
        /// 
        public void GetValuesForIndex(long sortIndex)
        {
            int size = _sortedValues.Length;

            if (sortIndex < 0)
            {
                throw new ArgumentException("sortIndex should be greater or equal to 0.");
            }

            if (sortIndex >= MaxIndex)
            {
                throw new ArgumentException("sortIndex should be less than factorial(the lenght of items)");
            }

            for (int n = 0; n < _valueUsed.Length; n++)
            {
                _valueUsed[n] = false;
            }

            long factorielLower = MaxIndex;

            for (int index = 0; index < size; index++)
            {
                long factorielBigger = factorielLower;
                factorielLower = Factorial.GetFactorial(size - index - 1); // factorielBigger/inverseIndex;

                int resultItemIndex = (int)(sortIndex % factorielBigger/factorielLower);

                int correctedResultItemIndex = 0;
                for(;;)
                {
                    if (! _valueUsed[correctedResultItemIndex])
                    {
                        resultItemIndex--;
                        if (resultItemIndex < 0)
                        {
                            break;
                        }
                    }
                    correctedResultItemIndex++;
                }

                Result[index] = _sortedValues[correctedResultItemIndex];
                _valueUsed[correctedResultItemIndex] = true;
            }
        }

       //************************************************************************
        /// 
/// Calc the index, relative to _sortedValues, of the permutation received /// as argument. Returned index is 0 based. ///
 
        /// 
        /// 
        public long GetIndexOfValues(T[] values)
        {
            int size = _sortedValues.Length;
            long valuesIndex = 0;

            List valuesLeft = new List(_sortedValues);

            for (int index = 0; index < size; index++)
            {
                long indexFactorial = Factorial.GetFactorial(size - 1 - index);

                T value = values[index];
                int indexCorrected = valuesLeft.IndexOf(value);
                valuesIndex = valuesIndex + (indexCorrected * indexFactorial);
                valuesLeft.Remove(value);
            }
            return valuesIndex;
        }

       //************************************************************************
    }
}
0
qo'shib qo'ydi
Matematiklar
Matematiklar
633 ishtirokchilar

Kanalga obuna buling @Matematikak Masala va misollar yechimlari uchun guruh Guruhda faqat matematikaga oid ma'lumot bo'lishi shart.

MATEMATIKA GRANT
MATEMATIKA GRANT
356 ishtirokchilar

Guruh muallifi : @Yusupov_Ahadjon Guruh rasmiy kanali @dtm_axborotnoma Kimda chiqmagan misoli bo'lsa guruhga jo'natishi mumkin! Guruh qoidalari Chat Reklama Soʻkingan Futbol Sticker Xamma bir birini xurmat qilsin

PhP |BotsUz
PhP |BotsUz
93 ishtirokchilar

Phpni o'rganishni Hohlasangiz https://t.me/joinchat/AAAAAE-KRc5dd5tPMmGmWA A'zo bo'lin