#String Concatenate

[duniailkom]

Tutorial Belajar C++: Cara Menyambung String

Ketika sedang membuat kode program, ada kalanya kita butuh menyambung 2 string atau lebih. Dalam tutorial bahasa pemrograman C++ kali ini kita akan bahas beberapa cara yang bisa dipakai untuk menyambungkan string, atau dikenal juga dengan istilah string concatenate. Cara Menyambung String dengan Operator Tambah (+) Cara yang paling umum untuk menyambung string dalam bahasa C++ adalah dengan…

[niuxita21]

Jimena! Amanda! Are you OK? Yes, we're OK. And it's thanks to you.

[horsescary]

man fuck operator overloading

[logiclitz]

Python String Concatenation: A Complete Guide

String concatenation is a fundamental concept in Python that allows you to combine two or more strings into one. This simple yet powerful technique is essential for various programming tasks, from creating dynamic text to managing user input. In this article, we’ll explore how to concatenate strings in Python, ensuring it’s easy to understand and highly optimized for SEO to help it rank first on…

[windsweptskies]

oh shit I'm onto something

Inspired by this post by @starlightwayfinder and @thetwilightroadtonightfall, I present the Brain Twitter Takeover!!!!

Each picture has a hidden secret- can you find them all?

[ostolero]

learned a new fuckening excel formula

after doing this kind of work for 10 years professionally

it's something incredibly obvious but I was doing it with writing out formulas because I'm too smart for my own good

background:

"upper()" and "lower()" are used on text strings to change the case of the letters. so for example:

upper("apple") = APPLE

lower("Fuck You") = fuck you

and so...

sometimes I would want to make a name like

diane mononym

or

DIANE MONONYM

into

Diane Mononym

and so I would use left() and right() and mid() to pull that shit out carefully and re-assemble it together. I was going to keep it brief because it's a bunch of bullshit but I decided to sit down and write out the formula because the people ought to see bullshit if they really wanted.

below the jump.

before we dive in, let me explain some of the formulas here for your reference.

some stuff with strings:

upper([string]) make the string upper case lower([string]) make the string lowercase concatenate([string) put the contents together as a single string left([string],[number]) take X-many characters off the left right([string],[number]) take Y-many characters off the right trim([string]) remove extra spaces from the string

and some stuff with math:

len([string]) measures how many characters there are in a string for example: "diane" is five (5) letters long, "mononym" is seven (7) characters long search([desired character],[string]): this is used to find a specific character in a string. so like here we'll look for " " the space character. which will denote how far in number of characters into the string that is so for example in "diane mononym" the space " " is six (6) characters in, where the name would be split in half

and so the strategy is to split the name into two words, then split the words into two parts, the first letter and the rest of the characters

so here we go.

the written-out formulas:

A1 ="diane mononym"

B2 =CONCATENATE(

UPPER(LEFT(TRIM(LEFT($A$1,SEARCH(" ",A1))))),

LOWER(RIGHT(TRIM(LEFT($A$1,SEARCH(" ",A1))),LEN(TRIM(LEFT($A$1,SEARCH(" ",A1))))-1)),

" ",

UPPER(LEFT(TRIM(RIGHT($A$1,LEN($A$1)-SEARCH(" ",$A$1))),1)),LOWER(RIGHT(TRIM(RIGHT($A$1,SEARCH(" ",A1))),

LEN(TRIM(LEFT($A$1,LEN($A$1)-SEARCH(" ",A1))))-1))

)

blink yet?

let me annotate this to explain what's happening here.

here's the formulas, annotated:

A1 ="diane mononym" // I wrote this out

B2 =CONCATENATE( // combine this as one string

UPPER(LEFT(TRIM(LEFT($A$1,SEARCH(" ",A1))))),

// use the space character to find out where the space is and grab the left of the two words, take the first character from the left and make it uppercase

LOWER(RIGHT(TRIM(LEFT($A$1,SEARCH(" ",A1))),LEN(TRIM(LEFT($A$1,SEARCH(" ",A1))))-1)),

" ",

// use the space character to find out where the space is and grab the left of the two words, take the remaining characters from the right and make them lowercase

UPPER(LEFT(TRIM(RIGHT($A$1,LEN($A$1)-SEARCH(" ",$A$1))),1)),LOWER(RIGHT(TRIM(RIGHT($A$1,SEARCH(" ",A1))),

// use the space character to find out where the space is and grab the right of the two words, take the first character from the left and make it uppercase

LEN(TRIM(LEFT($A$1,LEN($A$1)-SEARCH(" ",A1))))-1))

// use the space character to find out where the space is and grab the rightof the two words, take the remaining characters from the right and make them lowercase

)

the laborious result:

A1 = diane mononym

B2 = Diane Mononym

This works pretty nicely and with the individual components broken out, you can even do funky stuff like reformat the name to something like

Mononym, Diane

but astute readers will note a specific limitation of this method. what if your person has three names (a middle, naturally),

you are completely shit out of luck.

may as well start this at 9 AM because this is going to take longer than it has to. I am not going today though because getting here writing this has already taken up the better part of an hour.

and I went searching for this because reformatting a name like "KATHERINE HENNESY TEMPO" into "Katherine Hennessy Tempo" would have devoured my soul

but the trick is to use if we're hypothetically tackling this is to be able to count Z-many additional spaces to break up but it's not dynamic. you need to keep adding formulas for each additional segment. hell on earth so let's not

and that's where I arrived at too. hm maybe I'm not too ambitious for my own good.

and so I found it immediately on a brief and mundane stack overflow page. behold. the new formula I did not know existed before today

PROPER()

which does that automatically.

just makes the first letters of a word............ Proper.

Dynamic Mixed Case.

GUESS I better go Fuck Myself

GUESS I BETTER GO FUCK MYSELF

guess i better go fuck myself

Guess I Better Go Fuck Myself

thank you for reading

edit: 20 min later

[woahpip]

concatenate

written for @therebelcaptainnetwork Secret Santa 2024, for @jynjackets <3

Jyn’s not used to a string pulling. Her mama’s lied disconnected, dragging behind her like a balloon string devoid of all color except for a pale, white sheen when light hit it the right way. If only it were that easy to forget it was there. Papa’s hung, still connected, but it never tugged and though Jyn didn’t know how the strings worked, she thought if he was thinking of her, it would tug. Did he ever wonder where she was, what she was doing? Or was she an easy thing to forget? Saw’s laid much the same, a deeper red than Papa’s but just as slack. It was a thin string, disappearing from her sight often to then reappear like a slash of blood. He could forget her, she knew. He’d proven that.

The fourth string was puzzling.

(read the rest HERE on ao3)

[ahleidreams]

my lexicon apparatus

one of my main priorities in conlanging from the start is creating a sense of a rich etymological history. that kind of fractal complexity is fiendishly hard to keep track of though (especially for me), and the lexicon apps i've tried in the past haven't really served my purposes, so i've been working on this ridiculous tool in Sheets to keep track of my etymologies without regard to the actual word forms. this would be so much easier if i knew how to do software design but eh. anyway i thought i'd share a bit on how it works.

first i have a basic sheet just for inputting proto roots. i'm very non-committal about my word forms at this stage; many are still blank and most that aren't were auto-generated by Monke (which is great btw). most important is the keyword, which is how i look up entries.

under the hood i have a sheet sorted by keyword which is where the actual lookup happens.

here's where the magic happens. on this sheet i can just build forms using up to three etymon (haven't needed a fourth yet). i just enter the keyword for each etymon into the dropdowns and it looks up the rest of the form, then auto generates a new form that just concatenates the three morphs. this auto-generated form will be the output unless i override it, as we'll see next.

moving right to left, we see how the output is generated: by default, it just outputs the entry data of etymon 1, since in most cases we're only dealing with one morph. however i can use the checkboxes here to enable manual input for the new form. in this image we have a few compound words being created which naturally have new meanings, so we input them manually. it will use the auto-concatenated form unless i need direct control over how the concatenation happens, or in the case of reduplication (i'm not gonna try to automate reduplication). i haven't used the "intermediate forms" columns so much, but it's there just to write notes for irregular sound changes. the "export" columns are the final forms that get sent to their own sheet, again, sorted by keyword. also, this whole time, we've been building up (in hidden columns) a string of text that lets me visually see a summary of the etymology. this gets exported to the sorted sheet as well.

and this process is recursive, i have copies of this sheet for the other stages of my language that take in the data from the previous one.

. . .UNFORTUNATELY . . .

even when using only native Sheets functions, this process can be INCREDIBLY slow. i've split my data into five documents so far, but it only helps so much. it also means i have to manually copy/paste the export data from one document to another all down the line which is more than a little tiresome.

but i think what i have to show for it is more than worth it so far. the modern lexicon has some 200+ entries right now (nowhere near the ~10,000 it would need to be, like, a real language, but a good start). what's more, the forms retain the memory of their etymological history, so i can have forms like this:

that final column is the summary string that's been automatically built up over each stage of the language (though it's less complicated than it looks and the parentheses don't nest properly yet), but i can just look at it and see that this word is the imperfective stem of a transitive verb that means "return" (which is made using a no-longer productive causative suffix on an intransitive root), all with a dative suffix. and i don't have to remember that, and i can change the word forms whenever i please.

this is my most recent addition, which is just a little sheet where i can make sentences and visually see how it breaks up. i've been writing a little fable (which is something i *highly* recommend trying btw, i've made *so* much progress on my lang this way), but i sometimes make mistakes and sometimes forget how the sentence is put together, so having a visual aid like this i think will help me a lot.

it's not a perfect system. the hardest part i think is how slow it is, but it also sucks that when i change a form it can't exactly notify me about everything that will be affected by doing that, especially if i've manually entered a form at some point in that chain. the summary columns make these glitches easy to catch though.

overall this tool has been serving me well, and likely will continue to, so long as it runs at a tolerable speed.

[mr-abhishek-kumar]

Python Operator Basics

x or y - Logical or (y is evaluated only if x is false)

lambda args: expression - Anonymous functions (I don't know what the fuck is this, I have to look into it)

x and y - Logical and (Y is evaluated only if x is true)

<, <=, >, >=, ==, <>, != - comparison tests

is, is not - identity tests

in, in not - membership tests

x | y - bitwise or (I still have to learn bitwise operation)

x^y - bitwise exclusive or (I read this somewhere now I don't remember it)

x&y - bitwise and (again I have to read bitwise operations)

x<;<y, x>>y - shift x left or right by y bits

x+y, x-y - addition/concatenation , subtraction

x*y, x/y, x%y - multiplication/repetition, division, remainder/format (i don't know what format is this? should ask bard)

-x, +x, ~x - unary negation, identity(what identity?), bitwise complement (complement?)

x[i], x[i:j], x.y, x(...) - indexing, slicing, qualification (i think its member access), function call

(...), [...], {...} `...` - Tuple , list dictionary , conversion to string

[flohuman]

Add integers 32,767 times

1,000 moves

10,000 If statements

Concatenate a string

10,000 times

Read a 100 element table

100 tim

Otimes by indexing

Read a 100 element table

100 times by subscripting

Sieve of Eratosthenes for

2 iterations

[mourning-again-in-america]

Haskell voice: we have strings and growable vectors! you wanted linked lists, right?

like we made fun of PHP for having shit like mysql_escape_string and mysql_real_escape_string because mysql_escape_string had a horrible bug but they didn't want to remove it for compatibility reasons meanwhile C has the footguns and solutions of strcpy and strncpy and and printf and snprintf and vsnprintf.

At least PHP deprecated the mysql library and made a new one since PHP5!

[mirqmarq428]

Powershell syntax is not confusing

(you are just confused because posix compliant shells have corrupted your mind)

> do-action -param "string" $variable (do this first) [type]value

To declare a function:

function do-mythings {

param([int]$argument)

$argument + 5

}

> do-mythings -arg 5

10

That's all you need to get started.

Numbers are just numbers.

Inline math just works. Parentheses for order of operations.

Strings you put in quotes - double quotes allow interpolation, single quotes don't. This is the same as sh.

All variables are prefixed with $s. Even when declaring them. This makes slightly more sense than sh.

A region in {squirrelly braces} gets the [scriptblock] data type. It's like a lambda but comprehensible by mere mortals.

if (test) {success} else {fail} - the test is always executed first because (). Success and fail conditions only depending on the test. They're script blocks. No weird special syntax, if may as well be a user function.

Functions can be named anything, but the convention is Verb-PlaceThing. Not case sensitive.

Named arguments are specified with a single hyphen, like MIT Unix software (xorg for instance). If there is only one parameter the name is optional, etc. Param names can be abbreviated as long as they aren't ambiguous. This is also easy to follow with your own functions, unlike in sh (fricking hate getopt).

Types are inferred dynamically because it's easier to write scripts that way. If you need to force something (variable, expression, whatever) to have a specific type, put it in [brackets] beforehand. The type names are the same as c# and every other post-algol language. For comparison, posix shell only has one type, String.

To make an array, @(item1, item2, etc)

To make a hashtable, @{

key1 = val1

key2 = val2

}

Adding strings concatenates them together. Adding numbers adds their values. If this is not satisfactory, declare their types and it will work.

All expressions are technically objects with properties and methods. $var.property returns the value of that property. $var.invokeMethod() runs the method, which is just a function built into that data type by some poor intern 20 years ago.

Pipes (|) work similarly to sh, but transfer objects. The current object in the pipeline is always the variable $_.

As a bonus, here's a one-liner for opening Internet Explorer on Windows 11 (they lied, it's still there, they will never remove it)

(new-object -com "InternetExplorer.application").visible = $true

COM is an old windows api. Com Objects are just instances of apps. We open internet explorer as a com object.

The parentheses sets that as an expression, and its return value _is_ the exploder. It has properties like visibility, which is $false by default. This is boring so set it to $true. Now we have a real working instance of an app they've been trying to remove for years, because they can't actually remove it merely hide it away. As long as the windows api can parse HTML, this will still work.

[0x4468c7a6a728]

3, 21!!

3. any interesting dreams recently?

yes! the gaming scale for one, not mentioned in that post is that it for some reason came with a bunch of weights and magnets and had like, servo motors in it for some reason? and last night i had a dream about getting very very lost on my local bus system with @yoneda-emma

21. programming language that does string concatenation the best?

this is kind of a fucked up answer. but. i really like how rust handles strings in general, it's definitely not like, beginner friendly or anything but it forces you to be a lot more aware of how you're handling strings and i like that, also it being designed specifically for working with utf-8 is great

[blog-abap]

Concatenate New Syntax in SAP ABAP | ABAP Concatenate New Syntax in 7.4

 Learn how to use the new CONCATENATE syntax in SAP ABAP 7.4 and 7.5 to write cleaner and more efficient code. This tutorial covers the updated approach to concatenate in SAP ABAP, replacing the older syntax with a modern, streamlined version. If you're working with ABAP 7.4 or newer, mastering the ABAP concatenate new syntax is essential for professional development. We’ll show practical examples of how to concatenate strings in ABAP using this new syntax for concatenate in ABAP, making your code shorter and easier to read. Understanding the SAP ABAP concatenate new syntax is especially helpful for those transitioning to new ABAP features in SAP systems. Whether you're new to SAP ABAP or just upgrading your skills, this guide to concatenate in ABAP 7.4 and 7.5 is a must-watch.

[the-least-undefinable-ordinal]

A neat math problem

I remember last year I went to a talk given by a colleague of my thesis advisor, most of it was way too advanced for me but there was a neat problem (probably a standard one in information theory) that stuck with me.

I may be getting the specifics wrong but it goes something like this: you have to send large batches of text using only the symbols 0 and 1, there is no symbol for the blank space and you can't separate words by sending them in separate messages, I don't remember the reasoning behind this last restriction but my guess is that (a) it may be inefficient in terms of storage space for sufficiently long texts and (b) you run the risk of the messages being sent in the wrong order, in which case you wouldn't be able to deduce the original text.

The question is essentially "given a finite (but arbitrarily long) alphabet, how do you assign binary sequences to each symbol so there is no ambiguity?"

You can't just do something like a=0, b=1, c=00, and so on, since in that case the string 000 can either mean "ac" or "ca", you need some way to denote when you are done reading a sequence.

Spoilers under the cut in case you want to try to figure it out yourselves.

At this point the professor gave us a couple of minutes to think about it, the closest we got to some answer was "limit the sequence lenghts to a fixed natural number n and give the blank space a sequence of lenght n+1", but we were told the sequence for the blank space had to work for alphabets of arbitrary lenght (maybe to give room for additional symbols when needed).

The solution (or at least one of them) turned out to be "type each digit twice (so 101 would be 110011) and let 01 denote the space, that way you just have to read two characters at a time until you run into a 01, then you'll know the current sequence is over".

This kind of problem is much more representative of what doing math feels like than most of what is taught in schools, and it's kind of neat how it doesn't take much math education to solve it all, it's pure creative thinking.

Yesterday I posed this problem to my mom (a lawyer who has trouble with percentages, for reference) and she figured out a solution in like 30 seconds: "just type each symbol as a finite concatenation of 01s and let the blank space be 00" (translated from spanish).

It's not an optimal solution, it's wildly inefficient compared to the one the professor gave us, but (unlike the ones we had given) it works and she did it with very little math education, it was pure problem solving.