փոխարինել տուփի կառուցվածքում

rplc

Եթե ​​դա լիներ տող (ինչպես 'abcaba'), ապա կլիներ rplc-ի հեշտ լուծումը՝

'abcaba' rplc 'a';'3';'b';'4'
34c343

փոփոխել }

Եթե ​​դուք պետք է ունենաք այն որպես տուփային տվյալներ (եթե, օրինակ, «a»-ն ավելի բարդ բան է ներկայացնում, քան նիշը կամ ատոմը), ապա միգուցե կարող եք օգտագործել փոփոխել }:

L =: 'a';'b';'c';'a';'b';'a'
p =: I. (<'a') = L  NB. positions of 'a' in L
0 3 5
(<'3') p } L  NB. 'amend' "3" on those positions

վերը նշվածը դնելով դիադայի մեջ.

f =: 4 :'({.x) (I.({:x) = y) } y'  NB. amend '{.x' in positions where '{:x' = y
('3';'a') f L
┌─┬─┬─┬─┬─┬─┐
│3│b│c│3│b│3│
└─┴─┴─┴─┴─┴─┘

որը կարող եք օգտագործել ավելի բարդ պարամետրերում՝

   ]L =: (i.5);'abc';(i.3);'hello world';(<1;2)
┌─────────┬───┬─────┬───────────┬─────┐
│0 1 2 3 4│abc│0 1 2│hello world│┌─┬─┐│
│         │   │     │           ││1│2││
│         │   │     │           │└─┴─┘│
└─────────┴───┴─────┴───────────┴─────┘
   ((1;2);(i.3)) f L
┌─────────┬───┬─────┬───────────┬─────┐
│0 1 2 3 4│abc│┌─┬─┐│hello world│┌─┬─┐│
│         │   ││1│2││           ││1│2││
│         │   │└─┴─┘│           │└─┴─┘│
└─────────┴───┴─────┴───────────┴─────┘

_{btw, {.y y-ի առաջին կետն է; {:y y}-ի վերջին կետն է

ստորին տող

Ահա մի փոքր օգտակար ծրագիր, որը կարող եք տեղադրել ձեր գործիքատուփում.

   tr =: dyad def '(y i.~ ({." 1 x),y) { ({:" 1 x) , y'

   ] MAP =: _2 ]\  'a';3;  'b';4 
+-+-+
|a|3|
+-+-+
|b|4|
+-+-+

   MAP tr  'a';'b';'c';'a';'b';'a'
+-+-+-+-+-+-+
|3|4|c|3|4|3|
+-+-+-+-+-+-+

հենց ներքեւի գծի վերեւում

Օգտակար tr-ը բայ է, որն ընդունում է երկու արգումենտ (դիադ). աջ արգումենտը թիրախն է, իսկ ձախը՝ քարտեզագրման աղյուսակը: Աղյուսակը պետք է ունենա երկու սյունակ, և յուրաքանչյուր տող ներկայացնում է մեկ քարտեզ: Ընդամենը մեկ փոխարինում կատարելու համար ընդունելի է երկու տարրից բաղկացած վեկտորը (այսինքն՝ 2D աղյուսակի փոխարեն 1D ցուցակ, քանի դեռ ցուցակը բաղկացած է երկու կետից):

Նկատի ունեցեք, որ աղյուսակը պետք է ունենա նույն տվյալների տեսակը, ինչ թիրախը (այսպես, եթե դուք փոխարինում եք տուփերը, այն պետք է լինի տուփերի աղյուսակ, եթե նիշեր, ապա նիշերի աղյուսակ, թվեր՝ թվերի համար և այլն):

Եվ քանի որ մենք կատարում ենք «նման-նման» քարտեզագրում, քարտեզագրման աղյուսակի բջիջները պետք է ունենան նույն ձևը, ինչ թիրախի տարրերը, ուստի այն հարմար չէ տողերի փոխարինման առաջադրանքների համար, որոնք: կարող է պահանջել ձևի փոփոխություն: Օրինակ, ('pony';'horse') tr 'I want a pony for christmas'-ը չի աշխատի (չնայած, զվարճալիորեն, 'pony horse' tr&.;: 'I want a pony for christmas'-ը կաշխատի, պատճառներով, որոնց մեջ ես չեմ մտնի):

ներքեւի գծից շատ բարձր

Ձեր հարցին ոչ ոք չկա, ստանդարտ պատասխան: Ասել է թե՝ թարգմանություն անելու շատ տարածված արտահայտություն կա (tr կամ քարտեզագրում 1:1 իմաստով).

   FROM =: ;: 'cat dog bird'
   TO   =: ;: 'tiger wolf pterodactyl'

   input=: ;: 'cat bird dog bird bird cat'

   (FROM i. input) { TO
+-----+-----------+----+-----------+-----------+-----+
|tiger|pterodactyl|wolf|pterodactyl|pterodactyl|tiger|
+-----+-----------+----+-----------+-----------+-----+

Սա բաժանելու համար պարզունակ i.-ը որոնման ֆունկցիան է, իսկ պարզունակ {-ը՝ ընտրության ֆունկցիան (հիշատակ. i.-ը ձեզ տալիս է ձեր փնտրած տարրերի *i*նդեքսը):

Բայց վերը նշված պարզեցված ձևակերպումը կիրառվում է միայն այն դեպքում, երբ դուք ցանկանում եք բառացիորեն փոխարինել մուտքագրված ամեն ինչ, և FROM-ը երաշխավորված է ընդհանուր լինելու համար (այսինքն՝ մուտքի տարրերը սահմանափակված են այն ամենով, ինչ կա FROM-ում):

Այս հակասությունները պարզ ձևակերպումը դարձնում են համապատասխան առաջադրանքների համար, ինչպիսիք են տողերի տառերի փոխարկումը, որտեղ դուք ցանկանում եք փոխարինել բոլոր տառերը, և մենք նախապես գիտենք տառերի ընդհանուր տիեզերքը (այսինքն՝ այբուբենը վերջավոր է):

Բայց ի՞նչ կլինի, եթե մենք չունենք վերջավոր տիեզերք: Ի՞նչ պետք է անենք չճանաչված իրերի հետ. Դե ինչ, ինչ ուզում ենք: Ճկունության այս անհրաժեշտությունն է պատճառը, որ J-ում չկա մեկ, մեկ թարգմանչական ֆունկցիա. փոխարենը լեզուն ձեզ գործիքներ է տալիս՝ ձեր կարիքներին հատուկ լուծում ստեղծելու համար:

Օրինակ, վերը նշված օրինաչափության շատ տարածված ընդլայնումը փոխարինում-լռելյայն հասկացությունն է (չճանաչված տարրերի համար): Եվ, քանի որ i.-ը սահմանվում է որպես 1+#input վերադարձի համար՝ փնտրման մեջ չգտնված իրերի համար, ընդլայնումը զարմանալիորեն պարզ է. մենք պարզապես ընդլայնում ենք փոխարինման ցուցակը մեկ կետով, այսինքն՝ պարզապես ավելացնում ենք լռելյայնը:

   DEFAULT =: <'yeti'
   input=: ;: 'cat bird dog horse bird monkey cat iguana'

   (FROM i. input) { TO,DEFAULT
+-----+-----------+----+----+-----------+----+-----+----+
|tiger|pterodactyl|wolf|yeti|pterodactyl|yeti|tiger|yeti|
+-----+-----------+----+----+-----------+----+-----+----+

Իհարկե, սա կործանարար է այն առումով, որ շրջելի չէ. այն մուտքի մասին տեղեկատվություն չի թողնում: Երբեմն, ինչպես ձեր հարցին, եթե չգիտեք, թե ինչպես փոխարինել ինչ-որ բան, ավելի լավ է հանգիստ թողնել:

Կրկին, այս տեսակի ընդլայնումը զարմանալիորեն պարզ է, և այն տեսնելուց հետո ակնհայտ է. դուք ընդլայնում եք որոնման աղյուսակը ավելացնելով մուտքագրումը: Այսպիսով, դուք երաշխավորված կգտնեք մուտքագրման բոլոր տարրերը: Եվ փոխարինումը նույնքան պարզ է. դուք ընդլայնում եք փոխարինման ցուցակը ավելացնելով մուտքագրումը: Այսպիսով, դուք ի վերջո փոխարինում եք բոլոր անհայտ իրերը իրենցով:

   ( (FROM,input) i. input) { TO,input
+-----+-----------+----+-----+-----------+------+-----+------+
|tiger|pterodactyl|wolf|horse|pterodactyl|monkey|tiger|iguana|
+-----+-----------+----+-----+-----------+------+-----+------+

Սա այն ռազմավարությունն է, որը մարմնավորված է tr-ում:

վերին գծի վերևում. երկարացում

BTW, tr-ի նման օգտակար ծրագրեր գրելիս, J ծրագրավորողները հաճախ հաշվի են առնում N-չափական դեպքը, քանի որ դա լեզվի ոգին է: Ինչպես կա, tr-ը պահանջում է երկչափ քարտեզագրման աղյուսակ (և, պատահաբար, կընդունի երկու տարրերի 1-չափ ցուցակը, որը կարող է հարմար լինել): Բայց կարող է գալ մի օր, երբ մենք ցանկանանք փոխարինել ինքնաթիռը խորանարդի մեջ, կամ խորանարդը հիպերխորանարդի մեջ և այլն (տարածված է բիզնեսի հետախուզության հավելվածներում): Մենք կարող ենք ցանկանալ ընդլայնել կոմունալ ծառայությունը՝ ծածկելու այս դեպքերը, եթե դրանք երբևէ առաջանան:

Բայց ինչպես? Դե, մենք գիտենք, որ քարտեզագրման աղյուսակը պետք է ունենա առնվազն երկու չափս՝ մեկը՝ մի քանի միաժամանակյա փոխարինումներ պահելու համար, և մյուսը՝ փոխարինելու կանոնները (այսինքն՝ մեկ «տող» յուրաքանչյուր փոխարինման համար և երկու «սյունակ». նույնականացնել իրը և դրա փոխարինումը): Հիմնական բանն այստեղ այն է, որ դա ամենը է, ինչ մեզ անհրաժեշտ է: tr_ը ընդհանրացնելու համար մենք պարզապես պետք է ասենք, որ թքած ունենք այն մասին, թե ինչ կա այդ չափումների տակ: Դա կարող է լինել միայնակ նիշերի Nx2 աղյուսակ, կամ ֆիքսված երկարությամբ տողերի Nx2 աղյուսակ, կամ գծային հանրահաշվի որոշ նպատակների համար մատրիցների Nx2 աղյուսակ, կամ ... ո՞ւմ է դա հետաքրքրում: Մեր խնդիրը չէ։ Մեզ հետաքրքրում է միայն շրջանակը, ոչ թե բովանդակությունը:

Այսպիսով, եկեք ասենք, որ tr-ին.

   NB.  Original
   tr =: dyad def '(y i.~ ({." 1 x),y) { ({:" 1 x) , y'

   NB.  New, laissez-faire definition
   tr =: dyad def '(y i.~ ({."_1 x),y) { ({:"_1 x) , y'

Հարկային փոփոխություն, ինչպես տեսնում եք ;): Ավելի քիչ շողոքորթ. վարկանիշային օպերատորը " կարող է ընդունել դրական կամ բացասական փաստարկներ: Դրական արգումենտը թույլ է տալիս բային անդրադառնալ իր մուտքագրման բովանդակությանը, մինչդեռ բացասական արգումենտը թույլ է տալիս բային հասցեագրել իր մուտքագրման շրջանակը: Այստեղ "1 (դրական) կիրառում է {. x-ի տողերին, մինչդեռ "_1 (բացասական) այն կիրառում է x-ի "տողերի" վրա, որտեղ վախեցնող չակերտների մեջ "տողերը" պարզապես նշանակում են առաջին հարթության երկայնքով գտնվող տարրերը, նույնիսկ եթե դրանք լինում են 37-չափ հիպերուղղանկյուններ: Ո՞ւմ է հետաքրքրում:

Դե, մեկ տղա հոգ է տանում: tr-ի սկզբնական սահմանումը թույլ է տալիս, որ ամենածույլ ծրագրավորողը (,:'dog';'cat') tr ;: 'a dog makes the best pet'-ի փոխարեն գրի ('dog';'cat') tr ;: 'a dog makes the best pet': Այսինքն՝ բնօրինակ tr-ը (բոլորովին պատահաբար) թույլ է տվել պարզ ցուցակ՝ որպես քարտեզագրման աղյուսակ, որը, իհարկե, Nx2 աղյուսակ չէ, նույնիսկ վերացական, վիրտուալ իմաստով (որովհետև այն չունի առնվազն: em> երկու չափս): Միգուցե մենք կցանկանայինք պահպանել այս հարմարավետությունը: Եթե ​​այո, մենք պետք է օգտագործողի անունից առաջ մղենք այլասերված փաստարկներ.

tr =: dyad define
   x=.,:^:(1=#@$) x
   (y i.~ ({."_1 x),y) { ({:"_1 x) , y
)

Ի վերջո, ծուլությունը ծրագրավորողի հիմնական արժանիքն է:

Ահա ձեր խնդրածը կատարելու ամենապարզ ճանապարհը, որը ես կարող եմ մտածել.

   (3;3;3;4;4) 0 3 5 1 4} 'a';'b';'c';'a';'b';'a'
┌─┬─┬─┬─┬─┬─┐
│3│4│c│3│4│3│
└─┴─┴─┴─┴─┴─┘

ահա ևս մեկ մոտեցում

   (<3) 0 3 5} (<4) 1 4} 'a';'b';'c';'a';'b';'a'
┌─┬─┬─┬─┬─┬─┐
│3│4│c│3│4│3│
└─┴─┴─┴─┴─┴─┘

Հիպոթետիկորեն ասած, դուք կարող եք ընդհանրացնել նման արտահայտությունը, կամ կարող եք ցանկանալ այլընտրանք: Կարծում եմ, որ այստեղի մյուս պաստառները մատնանշել են դա անելու ուղիները: . Բայց երբեմն պարզապես ամենապարզ ձևը տեսնելը կարող է հետաքրքիր լինել:

Ի դեպ, ահա թե ինչպես եմ ես ստացել իմ վերը նշված ցուցանիշները (որոշ, բայց ոչ բոլոր անհամապատասխանությունները հանվել են).

   I. (<'a') = 'a';'b';'c';'a';'b';'a'
0 3 5
   ('a') =S:0 'a';'b';'c';'a';'b';'a'
1 0 0 1 0 1
   ('a') -:S:0 'a';'b';'c';'a';'b';'a'
1 0 0 1 0 1
   I.('a') -:S:0 'a';'b';'c';'a';'b';'a'
0 3 5
  I.('b') -:S:0 'a';'b';'c';'a';'b';'a'
1 4