SASS Exists in two forms: SASS File and SASS
Need a preprocessor
, LibSass is unusable on its own and must be wrapped by another library to provide an interface for compiling Sass stylesheets to CSS. The most popular wrapper for LibSass has to be node-sass6, a Node.js library that compiles Sass to CSS through LibSass
npm install node-sass -g
node-sass --watch input.scss output.css
curl -G -f www.google.com > output.html
curl -X POST https://example.com/api/endpoint -d @"input.txt"
Use netstat -aon to list all active connections with detailed information, including the local and remote ports. Note down the process ID (PID) corresponding to the desired connection. Run tasklist /FI "pid eq 1234" (replace 1234 with the noted PID) to find the program name and other details associated with that PID.
"The fix here is to tailor the interface based on what each client needs"
It is used to surface any backend server timing
In the context of surfacing backend server timing, the word "surface" means to make the information visible and accessible. It implies that the timing data isn't readily available or easily understood as-is, and this tool or process brings it to the forefront, making it clear and usable.
Hmm, having a method on a class that when called won’t do what its name implies is just bad… really, really bad. anytime you see code that takes in some sort of baseclass or interface and then performs a check such as “if (someObject is SomeType)”, there’s a very good chance that that’s an LSP violation. I’ve done that, and I know so have you, let’s be honest.
Sometimes, solid principles go hand in hand.
https://softwareengineering.stackexchange.com/a/431254/293140
- Calaudio Lassala
// #pragma GCC optimize("O3")
// #pragma GCC optimize("Ofast")
// #pragma GCC optimize("unroll-loops")
// #pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
// #pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include<bits/stdc++.h>
using namespace std;
using namespace chrono;
#define int long long
const int mod=1e9+7;
const int INF = 1e18;
/*/---------------------------------------------------------------------------------------------------------/*/
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
// https://csacademy.com/app/graph_editor/
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type>
istream& operator >> (istream &is, T_container &v) {
for(T &x : v) is >> x; return is;
}
#ifdef __SIZEOF_INT128__
ostream& operator << (ostream &os, __int128 const& value){
static char buffer[64];
int index = 0;
__uint128_t T = (value < 0) ? (-(value + 1)) + __uint128_t(1) : value;
if (value < 0)
os << '-';
else if (T == 0)
return os << '0';
for(; T > 0; ++index){
buffer[index] = static_cast<char>('0' + (T % 10));
T /= 10;
}
while(index > 0)
os << buffer[--index];
return os;
}
istream& operator >> (istream& is, __int128& T){
static char buffer[64];
is >> buffer;
size_t len = strlen(buffer), index = 0;
T = 0; int mul = 1;
if (buffer[index] == '-')
++index, mul *= -1;
for(; index < len; ++index)
T = T * 10 + static_cast<int>(buffer[index] - '0');
T *= mul;
return is;
}
#endif
template<typename A, typename B>
ostream& operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type>
ostream& operator << (ostream &os, const T_container &v) {
os << '{'; string sep;
for (const T &x : v) os << sep << x, sep = ", ";
return os << '}';
}
template<class P, class Q = vector<P>, class R = less<P> > ostream& operator << (ostream& out, priority_queue<P, Q, R> const& M){
static priority_queue<P, Q, R> U;
U = M;
out << "{ ";
while(!U.empty())
out << U.top() << " ", U.pop();
return (out << "}");
}
template<class P> ostream& operator << (ostream& out, queue<P> const& M){
static queue<P> U;
U = M;
out << "{"; string sep;
while(!U.empty()){
out << sep << U.front(); sep = ", "; U.pop();
}
return (out << "}");
}
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
int count_open = 0, len = 1;
for(int k = 1; ; ++k){
char cur = *(names + k);
count_open += (cur == '(' ? 1 : (cur == ')' ? -1: 0));
if (cur == ',' && count_open == 0){
const char* comma = names + k;
cerr.write(names, len) << " : " << arg1 << " | ";
__f(comma + 1, args...);
return;
}
len = (cur == ' ' ? len : k + 1);
}
}
#else
#define trace(...) 1
#endif
/* ----------------------------------------------------- GO DOWN ---------------------------------------------------------------------- */
void solve(){
int n;
cin>>n;
std::vector<int> v(n);
for(int i=0;i<n;i++){
cin>>v[i];
}
int mn = *min_element(v.begin(), v.end());
for(int i=0;i<n;i++){
if(v[i]==mn){
cout<<i<<endl;
return;
}
}
}
signed main(){
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
auto start1 = high_resolution_clock::now();
int t;
t=1;
// cin >> t;
// Hetu ka laptop
while (t--) {
solve();
}
auto stop1 = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop1 - start1);
cerr << "Time: " << duration . count() / 1000 << " ms" << endl;
return 0;
}
Wrapper function
=================
A function that is executed once the page has been finished loading
$(function () { //all our code will be in here... })
Most jQuery code that we see in the wild resides within some kind of wrapper like this. Using $(function(){}); is a shortcut to jQuery's document.ready function, which is fired once the DOM for the page has loaded
===============================
https://www.paulirish.com/2009/perf/
=========================
window object is also known as the Global Namespace. The main concept of namespacing is to provide a way to logically group all the related pieces of a distinct and self-contained part of an application.
To make something intelligent is to give it input parameters. Parameters which are nothing but additional valuable information which is needed to ensure that the program works efficiently and flexibly.
Buffering:
The cout stream in C++ is buffered by default, which means that the output is stored in a buffer before being actually written to the console. This buffering introduces some overhead. On the other hand, printf typically flushes the output immediately, reducing the buffering overhead.
