通过python或Tcl增加字符串中的数字

Question

I have some strings with integer numbers (From 2 to 5 numbers in one string, separated by spaces) this is an example:

    1    4    5   19
    1    5
    2    3    6   59
    2    6
    3    2    4   60
    3    4
    4    1    3   61
    4    3
   25   13   23   64   65
   13   18
   14   13   15   75
   14   15
   15   14   16   76
   15   14
   45   44  102  103  104

I need to increase all numbers by 129 repeatedly, so the beginning will be:

130  133  134 148
130  134
131  132  135 188  ...

Next increase will be:

259  262  263 277
259  263
260  261  264 317 ...

What is the best option for this type of string analysis? At first count the numbers, then make matrix filled with "0": [0, 0, 0, 0, 0] Than fill it - it will be: 1st line [1, 4, 5, 19, 0 ] 2nd line [1, 5, 0 , 0 , 0 ]

And increase all numbers which are not a zero. I am thinking about the solution for this task in right direction or there is more easier way? Or there is any ready solution and I just don't understand how to exactly search it?

The result must be with specific formatting - it is PDB file CONECT records .

Answer 1

If you know the final dimensions, you can pre-allocate a numpy array of zeros. Say what you how you want to handle each row initially ( process_row ), and then do that for every row in the file ( process_file ).

import numpy as np

def process_row(row, row_num, out):
    row = row.split()
    nvals = len(row)
    out[row_num,:nvals] = row

def process_file(fname, shape):
    data = np.zeros(shape)
    with open(fname) as fin:
        for i, row in enumerate(fin):
            process_row(row, i, data)
    return data

data = process_file(fname="C:/temp/temp.txt", shape=(15,5))
data[data != 0] += 129

Answer 2

A Tcl one, if you only need the numbers added up:

set text {    1    4    5   19
    1    5
    2    3    6   59
    2    6
    3    2    4   60
    3    4
    4    1    3   61
    4    3
   25   13   23   64   65
   13   18
   14   13   15   75
   14   15
   15   14   16   76
   15   14
   45   44  102  103  104}

proc addevery {txt amount} {
    # Creating an alias so we can modify the variable from outside the proc
    upvar text gtext
    set result [list]
    # Split to get lines
    foreach line [split $txt \n] {
        set lineresult [list]
        # Get each number added
        foreach item [regexp -all -inline {\S+} $line] {
            lappend lineresult [expr {$item+$amount}]
        }
        lappend result $lineresult
    }
    set gtext [join $result \n]
    puts $gtext
    return
}

puts "Adding 129:"
addevery $text 129

puts "\nAdding again 129:"
addevery $text 129

ideone demo

---

EDIT: After getting an understanding of the underlying problem; we have to keep the formatting (more specifically, adding CONECT before each line of series of numbers, keep the numbers with a 5 space right indented format and be able to output the different 'steps' of the addition to the original numbers in the same file. One last thing, the first iteration actually should not add anything to the original numbers.

set fin [open "Input.txt" r]
set fout [open "Output.txt" w]

set lines [split [read $fin] "\n"]

# Amount to be added each time
set amount 129
# Number of times to be added
set times 100

proc addevery {amount} {
  global lines
  # Result list
  set lresult [list]
  foreach line $lines {
    # Result line
    set result {}
    # Get every 5 chars of the line
    foreach item [regexp -all -inline {.{5}} $line] {
      # Add, format then append to result line
      append result [format %5s [expr {[string trim $item]+$amount}]]
    }
    # Add line to the result list
    lappend lresult $result
  }
  # Set the lines to the new lines
  set lines $lresult
  return $lresult
}

for {set i 0} {$i < $times} {incr i} {
  # If 0, put the original with CONECT
  if {$i == 0} {
    puts $fout [join [lmap x $lines {set x "CONECT$x"}] "\n"]
  } else {
    puts $fout [join [lmap x [addevery $amount] {set x "CONECT$x"}] "\n"]
  }
}

close $fin
close $fout

And as a bonus, the python equivalent:

amount = 129
times = 100

import re

def addevery(amount):
  global lines
  lresult = []
  for line in lines:
    result = ''

    for item in re.findall(r'.{5}', line):
      result += "%5s" % (int(item.strip()) + amount)

    lresult.append(result)

  lines = list(lresult)
  return lresult

with open('Input.txt', 'r') as fin:
  with open('Output.txt', 'w') as fout:
    lines = fin.read().split('\n')
    for i in range(0,times):
      if i == 0:
        fout.write('\n'.join(['CONECT'+i for i in lines]) + '\n')
      else:
        fout.write('\n'.join(['CONECT'+i for i in addevery(amount)]) + '\n')

Answer 3

You're looking for a two-dimensional array (wich is a matrix).

First of all, you can initialize it with 0's:

Matrix = [[0 for x in range(20)] for x in range(5)]

You have to change the number for the size you want. The 20 is the number of lines, the 5 is the number of columns.

After that, you can put the numbers on the spot you want, using this:

Matrix[r][c] = 1

Where, again, R is the row and C is the column.

IF you want to fill the matrix on the beggining, you can also go for:

Matrix = [ [1, 4, 5, 19, 0], [1, 5, 0, 0, 0], [0, 0, 0, 0, 0],
[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0] ]

And then use two for-loops inside each other to increase the numbers

for i in range(20):
   for j in range(5):
      Matrix[i][j] = Matrix[i][j] + 129

Answer 4

A couple of Tcl solutions. Assume the original text with numbers is in the variable str , see below.

One way to do this is by replacing all numbers with command invocations to do the calculation and then perform substitution on the string (formatting will be a little off since numbers will now be wider but whitespace remains the same):

set res [subst [regsub -all {\d+} $str {[expr {&+129}]}]]

Another way is to split the string up into a matrix of lines and numbers and traverse it:

set res {}
foreach line [split $str \n] {
    foreach n $line {
        append res [format %5s [incr n 129]]
    }
    append res \n
}

The same method using Tcl 8.6 lmap mapping commands:

set res [join [lmap line [split $str \n] {
    join [lmap n $line {
        format %5s [incr n 129]
    }] {}
}] \n]

In both cases, the resulting string will be in the variable res , with the original formatting preserved.

ETA: right-justified output:

set res [join [lmap line [split $str \n] {
    format %25s [join [lmap n $line {
        format %5s [incr n 129]
    }] {}]
}] \n]

The variable str is assigned like this, as plain text (newlines are trimmed of at the ends to avoid empty ghost elements):

set str [string trim {
    1    4    5   19
    1    5
    2    3    6   59
    2    6
    3    2    4   60
    3    4
    4    1    3   61
    4    3
   25   13   23   64   65
   13   18
   14   13   15   75
   14   15
   15   14   16   76
   15   14
   45   44  102  103  104
} \n]

Documentation: append , expr , foreach , format , incr , lmap , regsub , set , split , string , subst

Answer 5

Tcl: requires Tcl 8.6 for lmap

package require Tcl 8.6

# list of strings
set strings {
    {    1    4    5   19}
    {    1    5}
    {    2    3    6   59}
    {    2    6}
    {    3    2    4   60}
    {    3    4}
    {    4    1    3   61}
    {    4    3}
    {   25   13   23   64   65}
    {   13   18}
    {   14   13   15   75}
    {   14   15}
    {   15   14   16   76}
    {   15   14}
    {   45   44  102  103  104}
}

proc incr_all {listvar {n 1}} {
    upvar 1 $listvar lst
    set lst [lmap sublist $lst {lmap elem $sublist {expr {$elem + $n}}}]
}

proc format_strings {lst} {
    join [lmap sublist $lst {format [string repeat {%5s} [llength $sublist]] {*}$sublist}] \n
}

incr_all strings 119
puts [format_strings $strings]

output

  120  123  124  138
  120  124
  121  122  125  178
  121  125
  122  121  123  179
  122  123
  123  120  122  180
  123  122
  144  132  142  183  184
  132  137
  133  132  134  194
  133  134
  134  133  135  195
  134  133
  164  163  221  222  223

Answer 6

set incriment 127
set molecules 450
set fout [open "Results.txt" w]
close $fout

proc addevery {filein fileout amount times} {
  set fh [open $filein r]
  set fout [open $fileout a+]
  while {[gets $fh line] != -1} {
    set result {}
    foreach item [regexp -all -inline {.{5}} $line] {
      append result [format %5s [expr {[string trim $item]+($amount*$times)}]]
    }
    puts $fout "CONECT$result"
  }
  close $fh
  close $fout
}

for {set i 0} {$i < $molecules} {incr i} {
    addevery "Connections_.txt" "Results.txt" $incriment $i
}

Thanks to the https://stackoverflow.com/users/1578604/jerry It is working, but not optimised yet.