Послідовне виявлення голосування


51

Stack Exchange автоматично виявляє послідовне голосування (коли один користувач або відміняє чи скасовує багато публікацій іншого користувача) і скасовує його. У цьому виклику ви реалізуєте дуже-дуже простий детектор "серійного голосування".

Вхідні дані

Вхід - це рядок, що представляє список голосів. Кожна група з двох символів представляє голос - перший - це виборець, а другий - користувач, за якого голосують. Наприклад, наступний ввід

ababbccd

може бути проаналізований як ab ab bc cdі являє собою aголосування bдва рази, bголосування cодин раз і cголосування dодин раз.

Вхід буде складатися лише з малих літер, і це завжди буде рівна довжина> 0. Ви також не можете голосувати за себе (так ні aaабо hh).

Вихід

Для цілей цього виклику послідовне голосування визначається як будь-який даний користувач, який голосує за будь-якого іншого користувача три чи більше разів.

Вихід - скільки голосів має бути відхилено для кожного користувача (тобто, скільки голосів на кожного користувача було перевернуто, а не скільки голосів, які вони дали, було відмінено) у форматі [user][votes][user2][votes2].... Наприклад, вхід abababab( aголосування bчотири рази) повинен дати результат b4(чотири голоси були повернені aна " b)".

Вихід може бути в будь-якому порядку, який ви хотіли б, але і вхід, і вихід повинні бути окремими рядками, як описано вище.

Тестові справи

In                            Out
---------------------------------------------------------------------------
abababcbcbcbcbbababa          b7a3
edfdgdhdfgfgfgih              g3
jkkjjkkjjkkjljljljmlmlnmnmnm  j6k3m3
opqrstuv                      <none>
vwvwwvwv                      <none>
xyxyxyxyxyxyxyzyzyzyxzxzxz    y10z3
nanananananananabatman        a8
banana                        <none>

16
+1 для nanananananananabatmanтестового випадку.
дев'ять

Відповіді:


6

Піт, 22 байти

pM_srSsfttTtMM.gkcz2 8

Спробуйте в Інтернеті: Демонстрація або Тестовий набір

Пояснення:

pM_srSsfttTtMM.gkcz2 8
                 cz2     chop the input into pairs
              .gk        group these pairs by their value
           tMM           discard the first char in each pair in each group
       fttT              discard all groups, that contain less than three pairs
      s                  concatenate all groups to get a list of chars
     S                   sort all chars
    r                8   run-length-encoding
   s                     concatenate all (count,char) pairs 
  _                      reverse the order
pM                       print each element without separator

Приклад:

input:   ededgdhdfgfgfgihed
chop:    ['ed', 'ed', 'gd', 'hd', 'fg', 'fg', 'fg', 'ih', 'ed']
group:   [['ed', 'ed', 'ed'], ['fg', 'fg', 'fg'], ['gd'], ['hd'], ['ih']]
discard: [['d', 'd', 'd'], ['g', 'g', 'g'], ['d'], ['d'], ['h']]
discard: [['d', 'd', 'd'], ['g', 'g', 'g']]
concat.: ['d', 'd', 'd', 'g', 'g', 'g']
sort:    ['d', 'd', 'd', 'g', 'g', 'g']
rle:     [[3, 'd'], [3, 'g']]
concat.: [3, 'd', 3, 'g']
reverse: ['g', 3, 'd', 3]
print:   g3d3

34

Нечитабельна , 1830 1796 1791 1771 1762 1745 1736 1727 1626 1606 1577 байт

Вихід є в зворотному алфавітному порядку ( zдо a), але згідно з вашими правилами, що видається допустимим.

"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "

Пояснення

По-перше, щоб скласти враження про те, що можна нечитати, ось основна операція:

  • У вас є нескінченна стрічка цілочисельних комірок довільного розміру
  • Ви НЕ мати покажчик пам'яті , як в Brainfuck; натомість ви відмежуєте осередки за розташуванням на стрічці. Це означає, що ви можете “прочитати значення №4” або “значення читання # (значення читання №4)” (подвійний відвід).
  • Ви можете лише читати або записувати комірки пам’яті (не безпосередньо приріст / зменшення, як у Brainfuck).
  • Ви можете збільшувати / зменшувати значення в виразі. Таким чином, щоб збільшити осередок пам'яті , ви повинні прочитати , надбавка , писати , або інакше кажучи: write(x, inc(read(x))).
  • У той час, як циклі і потрійні умовні умови можуть перевіряти лише нуль проти не нуля.

Ця програма використовує стрічку наступним чином. Імена змінних будуть використані в псевдокоді нижче. Також цей документ першої версії (що склав 1830 байт); дивіться правки внизу про те, що змінилося з тих пір.

  • Комірка 0: зміннаq
  • Cell 1: змінні a, p,ch
  • Клітина 2: змінні hash,v
  • Клітина 3: змінні b,r
  • Клітина 4: змінні aa,l
  • В комірці 5: залишається 0, щоб позначити "кінець" рядка десяткових цифр
  • Клітини 6–95: зберігають рядок десяткових цифр назад
  • Осередки 96–121: зберігають кількість голосів, які слід відрахувати від користувачів a(96) до z(121) (код ASCII букви мінус один).
  • Клітини 4657–7380: пригадайте, які поєднання виборців / голосуючих стикалися вже не раз. Ці клітинки мають лише 4 можливі значення: 0= ще не бачили, -1= бачили один раз, -2= бачили двічі, -3= бачили будь-яку кількість разів більше 2.

Алгоритм по суті протікає таким чином:

  • Продовжуйте читати пари символів aі b. Обчисліть значення хеша (a-2)*(a-1)+b-1, яке є унікальним для кожної комбінації літер a – z.
  • Перевірте комірку пам'яті на це хеш-значення ( *hash). Якщо це так -3, користувач вже має право на видалення голосів, тому збільшується *(b-1). Інакше декремент *hash. Якщо це зараз -3 , користувач щойно отримав право на видалення голосів після трьох випадків, таким чином збільшуючи *(b-1)їх 3.
  • Після цього пройдіть символи у зворотному порядку ( zдо a) та виведіть ті, для яких потрібні голоси, що віднімаються. Це вимагає ручного цілого поділу на 10, щоб перевести число на десяткові цифри.

З урахуванням всього цього програма виглядає як псевдокод:

// Read pairs of characters
while (a = read) + 1 {
    b = read

    // Calculate hash = (a-1)*(a-2)/2 + b-1
    // This also sets a = b-1
    hash = 0
    while --a {
        aa = a
        while --aa {
            ++hash
        }
    }
    while --b {
        ++a
        ++hash
    }

    // If this combination has just been seen for the third time,
    // increment *a by 3; if more than third time, increment *a by 1
    *a = (*hash + 3) ? ((--*hash) + 3 ? *a : (*a+3)) : (*a+1)
}

// Loop through the characters z to a
l = 27
while --l {                     // l loops from 26 to 1 (not 0)
    (v = *(ch = l + 95)) ? {    // 'a' is ASCII 97, but cell 96
        print (ch+1)            // print the votee

        // Now we need to turn the number v into decimal.
        // p points to where we are storing decimal digits.
        p = 5

        while v {
            // Integer division by 10 (q=quotient, r=remainder)
            r = (q = 0)
            while v {
                --v
                (++r - 10) ? 1 : {
                    r = 0
                    ++q
                }
            }
            // Store digit ASCII character
            *(++p) = r + 48     // 48 = '0'
            v = q
        }

        // Now output all the digit ASCII characters in reverse order
        while *p {
            print *(--p + 1)
        }

    } : 1
}

Редагувати 1, 1830 → 1796: Зрозуміло, що я можу повторно використовувати повернене значення циклу час в одному місці.

Редагувати 2, 1796 → 1791: Виходить програма трохи меншою, якщо замість ячеек 6–95 я зберігаю десяткові цифри у колах з відмітною нумерацією (–1 далі). Як додатковий бонус, програма більше не обмежується 10⁹⁰ голосами!

Редагування 3, 1791 → тисяча сімсот сімдесят один: Замість присвоєння результату *(ch = l + 95)до v, я тепер призначити його , qа потім перемістити завдання v = qв стан в той час, приймаючи код 1777 байт. Потім поміняйте місце розташування qта vна стрічку, тому що qзараз це більше, ніж 1 v.

Редакція 4, 1771 → 1762: Дюх. Ініціалізація hashдо 1 замість 0 на 9 байт коротша. Хеш-код тепер є ще 1, що не має значення.

Редагувати 5, 1762 → 1745: Якщо я ініціалізую qі rдо 1 замість 0, мені доведеться посипати -1місцями s, щоб зробити його правильним, і все, здається, скасувати - за винятком того, що while v { --v; [...] }цикл тепер повинен виконати одну меншу ітерацію, що я можу зробити, сказавши while --v { [...] }, що на 26 символів коротше.

Правка 6, 1745 → 1736: Замість цього { r = 1; ++q }ми можемо писати q = *((r = 1)+1)+1. Це покладається на те, що qє в слоті №2 змінної. Якби це було в слоті №1, це було б ще коротше, але тоді вся програма була б довшою загалом.

Edit 7, 1745 → 1727: Reverted Edit 6 і замість цього досягнув економії, включивши внутрішню петлю до виразу, що обчислює цифру ASCII-коду, який також закінчується в 1736 байт ..., але потім зберігається інструкція про декремент (9 байт ), змінивши ((++r) - 11) ? r :на (r - 10) ? ++r :.

Редагувати 8, 1727 → 1626: перероблено хеш-розрахунок. Тепер він використовує один менший цикл while. Місце розташування комірок тепер знаходиться за своїми фактичними кодами ASCII (більше 1 не вимикається). Перестановляйте змінні в різні місця на стрічці, оскільки вони зараз трапляються з різною частотою.

Редагуйте 9, 1626 → 1606: Більш божевільний вклад. Тіло першого циклу while виглядає приблизно так:

// b = next char
*(b = (hash = read)) = {

    // hash = b + (a-1)*(a-2)/2
    while (a2 = --a) {
        while --a2 {
            ++hash
        }
    }

    // If this combination has just been seen for the third time,
    // increment *b by 3; if more than third time, increment *b by 1
    (*hash + 3) ? ((--*hash) + 3 ? *b : (*b+3)) : (*b+1)
}

і призначення змінної тепер майже повністю змінилося.

Редагування 10, 1606 → 1 577: Я помітив , що aі a2обидва декрементируется 0 в той час як петлі, так що, якщо я міг би пару pні з одним з тих , хто, але НЕ з ch, я не повинен був би ініціювати pдо 0(який коштує 29 байт). Виявляється, я можу це зробити, замінивши pі r. Найновіші змінні призначення (та їх частота зустрічань у коді) тепер:

0 = v (3)                    (total  3)
1 = hash (6), r (5), ch (2)  (total 13)
2 = b (4), q (5)             (total  9)
3 = a (3), p (5)             (total  8)
4 = a2 (3), l (4)            (total  7)

1
Бачачи, як для нових голосів для нових голосів необхідний рядок розміром 2 * 10 ^ 90 байт, а поточний найменший можливий об'єм 10 ^ 24 байт приблизно на 1/3 розміру Великої піраміди в Гізі , я не думаю, що у вас є про що турбуватися. ;)
ETHproductions

1
@ETHproductions: Тим не менше, гольфуючи програму, мені довелося виправити це обмеження :)
Timwi

22

CJam, 23 байти

Вечірка довжиною!

q2/$e`{3a>},e~Wf=$e`Wf%

або

qW%2/$e`{3a>},e~:ce`Wf%

Запустити всі тестові справи

Пояснення

q2/   e# Read input and split into pairs.
$e`   e# Sort and run-length encode - this tallies the pairs.
{     e# Filter the tallies...
  3a> e#   Keep only those which start with a 3 or greater.
},    e# Now we need to group the remaining pairs.
e~    e# Run-length decode the remaining pairs.
Wf=   e# Select the second character from each pair (the one being voted on).
$e`   e# Tally the characters by sorting and RLE'ing again.
Wf%   e# Reverse each pair, because CJam's RLE has the number first and the character last.

Інша версія починається з реверсування пар, що зберігає два байти в іншому місці: а) вибір першого символу в кожному рядку відбувається лише :cзамість Wf=вибору другого. б) Нам не потрібно повторно сортувати перед другим RLE, оскільки пари вже були відсортовані в основному за символом, що залишився.


FWIW Qу вашій другій відповіді має бути qдля непроверної обгортки.
Пітер Тейлор

@PeterTaylor Я роблю це весь час -.-
Мартін Ендер

Я знаю, що це незначна деталь, але перетворення списку 3на список для порівняння - приємна хитрість. Я вирішив це просто заради власної розваги, і втратив там байт, бо звик 0=2>. Інакше я закінчив майже те саме, що і ваше перше рішення, за винятком використання ::\ замість Wf%останнього кроку.
Рето Коради

10

Баш, 95 94 85 81 байт

fold -2|sort|uniq -c|awk '$1>2{c[substr($2,2)]+=$1}END{for(x in c)printf x c[x]}'

Елегантне, але довге перше рішення для початку ...

Завдяки User112638726 за збереження байта sed, DigitalTrauma для збереження 9 з fold, та Rainer P. за збереження ще 4 за допомогою awk's substr!

Щоб побачити, як це працює, давайте візьмемо вклад abababcbcbcbcbbababa.

  • Після fold -2(оберніть лінію на ширину 2), маємо

    ab
    ab
    cb
    cb
    cb
    cb
    ba
    ba
    ba
    
  • Після sort | uniq -c( -cце дуже витончений прапор, uniqякий видає кількість підрахунків, скільки разів кожен рядок з'являється на вході), ми отримуємо

          3 ab
          3 ba
          4 cb
    
  • Тепер розглянемо остаточну awkкоманду:

    • $1>2: Виведіть лише те, якщо запис 1 (він же кількість однакових голосів) перевищує 2 (тобто ≥ 3). Іншими словами, ігноруйте будь-який рядок, який починається з числа ≤ 2.

    • {c[substr($2,2)]+=$1}: Якщо число більше, ніж 2, додайте це число до cхеш-таблиці, використовуючи друге символи запису 2 (він же голос-е-е) в якості ключа. (Нам не потрібно ініціалізувати все до нуля; awkце робить для нас.)

    • END{...}: Це просто означає "після обробки всього файлу, ось що робити далі".

    • for(x in c)printf x c[x]: Досить зрозуміло. Роздрукуйте кожну клавішу та відповідне її значення.


&еквівалент до \0sed
User112638726

@ User112638726 Не знав цього, дякую
Doorknob

Трохи sed -r 's/.(.)/\1\n/g'|awk '{a[$1]++}END{for(i in a)printf (a[i]>2)?i a[i]:y}
скоротили

@ User112638726 Наприклад, це не вдається для введення даних bacada.
Дверна ручка

О так, моє погано!
User112638726

8

JavaScript, 114 113 110

f=s=>eval('o={},s.replace(/../g,m=>s.search(`^((..)*${m}){3}`)?0:o[c=m[1]]=~~o[c]+1);r="";for(v in o)r+=v+o[v]');

Тестові приклади:

На високому рівні цей код заповнює об'єкт парами "ключ-значення", які відображають отримувачів голосів на кількість голосів, як-от, { b:7, a:3 }а потім з'єднують їх у рядок у forциклі. Код у evalвиразі, що дозволяє використовувати forфункцію стрілки без необхідності витрачати байти на { }та ;return r.

(Реквізит до користувача81655 для збереження трьох байтів!)

Пояснення evalкоду:

o={},                             // object to hold name/vote mapping
s.replace(/../g,                  // for each pair of chars in input
  m=>s.search(`^((..)*${m}){3}`)  // see if pair appears 3 times
                                  //   (0 if true, -1 if not)
     ?0                           // if not, do nothing
     :o[c=m[1]]=~~o[c]+1          // if yes, increment the property named after
                                  //   the second character in the pair
);
r="";                       // return string
for(v in o)r+=v+o[v]        // populate string with characters and vote totals

6

Haskell, 103 байти

import Data.Lists
f s|c<-chunksOf 2 s,b<-[e!!1|e<-c,countElem e c>2]=nub b>>= \q->q:show(countElem q b)

Приклад використання: f "jkkjjkkjjkkjljljljmlmlnmnmnm"->"k3j6m3"

Як це працює:

c<-chunksOf 2 s                      -- split the input into lists of 2 elements
b<-[e!!1|e<-c,countElem e c>2]       -- for every element e of that list take the 2nd
                                     -- char if there are more than 2 copies of e
nub b>>= \q->q:show(countElem q b)   -- take every uniq element thereof and append
                                     -- the number how often it appears 

6

JavaScript (ES6), 195 174 169 167 158 байт

s=v=>eval("a={},b={},e='';(v.match(/../g)).forEach(c=>{a[c]=(a[c]||0)+1});for(var k in a){d=k[1];a[k]>2&&(b[d]=(b[d]||0)+a[k])};for(var k in b){e+=k+b[k]};e")

Тест


1
Ласкаво просимо до PPCG :) У нас є кілька порад щодо гольфу в JS тут і тут . Сам я не знаю достатньо добре, щоб справді допомогти, але щасливий гольф :)
FryAmTheEggman

1
З одного боку, ви можете видалити vars. Кого хвилює забруднення глобальної сфери застосування кодового гольфу? ;)
Дверна ручка

Крім того, /(\w{2})/gможе бути просто /../g- ми вже знаємо, що введення - це лише літери, а повторення одного (або двох) символів коротше, ніж {2}. Якщо ви зацікавлені, ви можете подивитися (і прокоментувати питання) мою відповідь JavaScript на це завдання. Ласкаво просимо до PGCC!
апсилери

4

Mathematica, 110 100 99 байт

g=Cases[Tr@#,#2,All]&;""<>g[g[BlockMap[$,Characters@#,2],i_*_/;i>2]/.$->Last,i_*x_:>x<>ToString@i]&

3

Perl, 86 84 83 байт

s/../$h{$&}++/eg;@l=%l=map{/./;$h{$_}>2?($',${$'}+=$h{$_}):()}keys%h;$"="";$_="@l"

Це 82 байти плюс 1 для -pаргументу командного рядка:

$ echo xyxyxyxyxyxyxyxyzyzyzyxzxzxz | perl -p 86.pl
y11z3


Дещо незворушний:

s/../$h{$&}++/eg;     # construct hash %h with pair counts

@l = %l = map         # assign to array via hash to filter dupes
{                     
  /./;                # match the first character

  $h{$_}>2?           # filter on 3 or more identical votes
  (                   # return a 2 element list (k/v pair for %l):
    $',               # $POSTMATCH: the 2nd character (votee)
    ${$'} += $h{$_}   # increment votee total votes, value is new total
  )
  :()
}
keys %h;              # iterate the unique pairs

$" = "";              # set $LIST_SEPARATOR to empty string
$_ = "@l"             # implicit join using $";  $_ gets printed with -p
  • оновлення 84 Збережіть 2 байти, вставивши грейп
  • оновлення 83 Збережіть 1 байт, використовуючи глобальні тимчасові VAR ${$'}замість $g{$'}. На жаль, $$'не працює.

3

Чистий Баш, 151

Довше, ніж я сподівався, але ось воно.

declare -A a n
for((;v<${#1};v+=2));{((a[${1:v:2}]++));}
for u in ${!a[@]};{((a[$u]>2))&&((n[${u:1}]+=a[$u]));}
for u in ${!n[@]};{ printf $u${n[$u]};}

Використовує індексацію асоціативного масиву для здійснення необхідного підрахунку. Потрібна версія bash 4.0 або новіша.


1

PHP 247 символів

(ой)

$f='';for($i=0;$i<strlen($s);$i=$i+2){$a[]=$s[$i].$s[$i+1];}$r=[];for($i=0;$i<count($a);$i++){$t=array_count_values($a);$c=$t[$a[$i]];if($c>=3){$r[$a[$i][1]][$a[$i][0]]=$c;}}for($i=0;$i<count($r);$i++){$f.=key($r).array_sum(current($r));next($r);}

Пояснив

// Test Case
$s = 'nanananananananabatman';

// Final result here
$f = '';

// Seperate strings into array in 2 character chunks
for ($i = 0; $i < strlen($s); $i = $i + 2)
{
    $a[] = $s[$i] . $s[$i + 1];
}

// Make an array of data
// The first level of array has voted on user as key
// Inside of that array is a dictionary with the voter user as the key, and the number of votes as the value
$r = [];
for ($i = 0; $i < count($a); $i++)
{
    $t = array_count_values($a);
    $c = $t[$a[$i]];
    if ($c >= 3)
    {
        $r[$a[$i][1]][$a[$i][0]] = $c;
    }
}

// Combine votes from different users to the same user into the final result string
for ($i = 0; $i < count($r); $i++)
{
    $f .= key($r) . array_sum(current($r));
    next($r);
}

echo $f;

Зробив це, не заглядаючи на інші відповіді. Це найскладніший гольф з кодом, який я вирішив поки. Я вітаю всі оптимізації.


0

R, 221 байт

код

f=function(s){t=strsplit(gsub("(.{2})","\\1 ", s)," ")[[1]];z=table(t)[table(t)>2];n=substr(names(z),2,2);x=data.frame(y=z,t=n);a=aggregate(x$y,by=list(x$t),sum);for(i in nrow(a):1)cat(as.character(a[i,1]),a[i,2],sep="")}

неозорий

f <- function(s){
  l <- gsub("(.{2})", "\\1 ", s)
  t <- strsplit(l," ")[[1]]
  z <- table(t)[table(t)>2]
  n <- substr(names(z),2,2)
  x <- data.frame(y=z,t=n)
  a <- aggregate(x$y, by=list(x$t),sum)
  for(i in nrow(a):1){
    cat(as.character(a[i,1]),a[i,2],sep="")
  }
}

Тут є багато можливостей для вдосконалення.

Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.