[Question]
  [
*Title is an homage to [this classic challenge](https://codegolf.stackexchange.com/questions/113238/is-it-true-ask-jelly)*
In [Pip](https://github.com/dloscutoff/pip), the Scalar data type encompasses strings and numbers. A Scalar value is truthy in most cases. It is falsey only if:
* It is the empty string `""`; or
* It is some representation of the number zero.
A Scalar is considered to be a representation of zero if:
* It consists of one or more `0`s; or
* It consists of one or more `0`s plus a single `.` anywhere among them.
The decimal point can be in the middle, at the beginning, or at the end.
## Challenge
Given a string containing printable ASCII characters, determine whether it is a truthy Scalar or a falsey Scalar according to Pip.
The default allowable output formats for [decision-problem](/questions/tagged/decision-problem "show questions tagged 'decision-problem'") apply: you may either output a truthy/falsey value in your language, with swapping allowed, or choose two consistent values, one representing truthy and the other representing falsey.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"); the goal is to minimize the size of your source code, measured in bytes.
## Examples
Falsey:
```
""
"0"
"000"
".0"
".00"
"0."
"00."
"0.00"
"0000000000000.00000000000000"
```
Truthy:
```
"abc"
"x"
"0001"
"0x00"
"0e0"
" 0"
"0 "
"+0"
"-0"
"."
"0.0.0"
"0.00000000000000000000000001"
```
## Reference implementation
This Python 3 code is adapted from the actual Pip interpreter:
```
import re
zeroRgx = re.compile(r"^(0+(\.0*)?|0*\.0+)$")
def truthy(value):
    return value != "" and not zeroRgx.match(value)
```
[Try it online!](https://tio.run/##jY/PSsQwEMbvfYpx8NBsNUS8LRTx4gOIN/9A6M7aQpqEJJWt@O41nRRUPGggX2a@YWZ@8XPqnb1elmH0LiQIVL1TcPevJ2hzIjs3@sFQHfClVk39JNVO3HyoXQ4acY6iOtARUphSP9dv2kwk9hXkEyhNwQJbcNYCImh7AOsSbPPlqFPXb02LD4NNNd5pE2ne57lHF9ZuGCw8Il6gWq9aVRZhQ7LLujnfj/yRKXwubDpGyl/9ohbQtsCruV5YAvnARVEVQ1RbgA/c@YtSl/1X63NiGmAkyNKs0SWTF1j5B07e8U@aW2MgUUzQ6UgRfJ6HYvkE)
  
[Answer]
# [Python](https://www.python.org), 29 bytes
```
lambda s:s.strip("0")in"."!=s
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vweI025ilpSVpuhZ7cxJzk1ISFYqtivWKS4oyCzSUDJQ0M_OU9JQUbYsham7uLSjKzCvRiE7TyNRUSMsvUshUyMxT0FBS0uECqgYRBmBKD0pCxPQgMhAKJogM9FB4QGtjNblw2JQI1WwIpisghilAjFQAkdpgti7EAVAb9SBGQjyxYAGEBgA)
Outputs True for falsy and False for truthy.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 23 bytes
```
s=>/[^0.]/.test(s)|s!=0
```
[Try it online!](https://tio.run/##VY49DsIwDIV3nyJMTYTqmrlKN07BjxqVFopKU8UWYuDuwWUCy5a@J/s9@R6egbs0LlLO8dLnwWf2TXU4E54qlJ7FsnvzxlMW400LBEQEuLYiqtL58m/hnyII63oH9FI2emtgS1BqyOrVsBYljQ/rkJdpFFsc58LVIDjEtA/dzbLxjenizHHqcYpXO@hbztX5Aw "JavaScript (Node.js) – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 7 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
„+-₂‡{Ā
```
[Try it online](https://tio.run/##yy9OTMpM/f//UcM8bd1HTU2PGhZWH2n4/1/bAAA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfeX/Rw3ztHUfNTU9alhYfaThv87/aCUlHSUDEDYAkXoQAiygBxYFk1ARZKCHwgNKKyglQtQYgqgKsA4FsDYFIKENYumCTYcYCLYpOhZIpCXmFKcCaSOQBFiJAVi1QaqBUiwA).
**Explanation:**
```
    ‡    # Transliterate in the (implicit) input-string
„+-      # all "+" and "-"
   ₂     # to "2" and "6" respectively
     {   # Sort all characters in this string (based on codepoint)
      Ā  # 'Python-style' truthify this sorted string
         # (which is output implicitly as result)
```
The new 05AB1E is built in Elixir.  
With just `Ā`, the `0.` and `00.` test cases are incorrectly truthy instead of falsey and the `+0`, `-0`, and `0e0` test cases are incorrectly falsey instead of truthy. The sort `{` is to fix `0.`, `00.`, and `0e0` and the transliterate `„+-₂‡` to fix `+0` and `-0`.
---
# [05AB1E (legacy)](https://github.com/Adriandmen/05AB1E/tree/fb4a2ce2bce6660e1a680a74dd61b72c945e6c3b), 8 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
…+- ₁‡{Ā
```
[Try it online](https://tio.run/##MzBNTDJM/f//UcMybV2FR02NjxoWVh9p@P/fINUAAA) or [verify all test cases](https://tio.run/##MzBNTDJM/V9Waa@k8KhtkoKSfeX/Rw3LtHUVHjU1PmpYWH2k4b/O/2glJR0lAxA2AJF6EAIsoAcWBZNQEWSgh8IDSisoJULUGIKoCrAOBbA2BSChDWLpgk2HGAi2KToWSKQl5hSnAmkjkARYiQFYtUGqgVIsAA).
**Explanation:**
```
     ‡    # Transliterate in the (implicit) input-string
„+-       # all "+", "-", and " "
    ₁     # to "2", "5", and "6" respectively
      {Ā  # Same as above
          # (after which the result is output implicitly)
```
The legacy version of 05AB1E is built in Python 3.  
With just `Ā`, the  `0`, `0` , `+0`, `-0`, and `0e0` test cases are incorrectly falsey instead of truthy. The transliterate `…+- ₁‡` is to fix  `0`, `0` , `+0`, and `-0`, and sort `{` is to fix `0e0` (thanks to *@JonathanAllan* for noticing a bug with this `0e0` test case).
---
# [2sable](https://github.com/Adriandmen/2sable/blob/master/Info.txt), ~~11~~ ~~10~~ 9 [bytes](https://en.wikipedia.org/wiki/Windows-1252#Codepage_layout)
```
'.Q«Ô0Þså
```
Outputs an inverted boolean.
[Try it online](https://tio.run/##MypOTMpJ/f9fXS/w0OrDUwwOzys@vPT/fz0A) or [verify all test cases](https://tio.run/##MypOTMpJ/V9Waa@k8KhtkoKSfaXLf3W9wEOrD08xODyv@PDS/zr/o5WUdJQMQNgAROpBCLCAHlgUTEJFkIEeCg8oraCUCFFjCKIqwDoUwNoUgIQ2iKULNh1iINim6FggkZaYU5wKpI1AEmAlBmDVBqkGSrEA).
**Explanation:**
```
'.Q       '# Check if the (implicit) input is equal to "."
   «       # Append this 1 or 0 to the (implicit) input
    Ô      # Connected uniquify (uniquifies groups of adjacent equal characters)
     0     # Push integer 0
      Þ    # Floatify and then stringify it: "0.0"
       så  # Check if the connected uniquify string is a substring of this
           # (so one of "", "0", "0.", ".0", "0.0", or "."†)
           # (which is output implicitly as result)
```
2sable is built in Python 3 as well, and is the oldest of the three versions and predecessor of the legacy 05AB1E version.  
It lacks a lot of the builtins, including the `Ā` we use in the other two programs, so I had to find an alternative. I ended up using the connected uniquify builtin `Ô` and check whether the result is one of `""`, `"0"`, `"0."`, `.0"`, `"0.0"`. I do this by checking whether it's a substring of `"0.0"`.  
† After which only the `"."` test case would incorrectly give a truthy instead of falsey result, which I've fixed by adding a leading `'.Q«`.
[Answer]
# Trivial [Pip](https://github.com/dloscutoff/pip) answers, 1 byte
Thanks to [decision-problem](/questions/tagged/decision-problem "show questions tagged 'decision-problem'") defaults, the identity function/program is a solution in Pip, since it turns falsey inputs into falsey outputs and truthy inputs into truthy outputs. Therefore, either of these full programs will work when given input as a command-line argument:
```
a
g
```
This program will work when given input on stdin:
```
q
```
And this works as a function solution:
```
_
```
While we're at it, logically negating the input gives some two- and three-byte solutions:
```
!a
!q
\!_
```
I'm making this post as a community wiki to head off these obvious answers (and other trivial solutions such as `@g` or `{a}` that are basically the same thing but longer). You are encouraged to post your own *non*-trivial Pip solutions.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 9 bytes
```
∧№.⁻θ0⁻.θ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMMxL0XDOb8UyFLSU9JR8M3MKy3WKNRRUDJQ0tSE8cFShZqamtb//@v91y3LAQA "Charcoal – Try It Online") Link is to verbose version of code. Outputs `.` for truthy, nothing for falsy. Note: Due to bugs in Charcoal's input, you need to input an empty string using a blank line. Explanation: Port of @Albert.Lang's Python answer.
```
 №          Count of
    θ       Input string
   ⁻ 0      With `0`s removed
  .         In literal string `.`
∧           Logical And
       .    Literal string `.`
      ⁻ θ   With input string removed
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), ~~16~~ 15 bytes
```
1`0\.|\.0
^0*$
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7w3zDBIEavJkbPgIsrzkBL5f9/Ay4DAwMuPRACMvWAPCAGs5GBHgrPgCsRJG3IZVABZCsA1SpwaRtw6QINAenVMwAA "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation:
```
1`0\.|\.0
```
Delete at most one `.` adjacent to a `0`.
```
^0*$
```
Match any number of zeros.
[Answer]
# [Vyxal](//github.com/Vyxal/Vyxal), 11 bytes
```
`+- `₈ĿṅsEḃ
```
[Try it online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJgKy0gYOKCiMS/4bmFc0XhuIMiLCIiLCJcIiswXCIiXQ==)
Port of Kevin Cruijssen's 05AB1E (legacy) answer.
### Explanation
```
`+- `₈ĿṅsEḃ
      Ŀ     # Transliterate the (implicit) input,
`+- `       # Replacing the characters "+", "-" and " "
     ₈      # With the characters "2", "5" and "6" respectively
       ṅ    # Join the list created by nothing
        s   # Sort the string
         E  # Evaluate the string
          ḃ # And convert to a boolean (Python-style)
```
[Answer]
# [Factor](https://factorcode.org) + `math.unicode`, 45 bytes
```
[ dup "0"without "."subseq? swap "."≠ and ]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=VU8xDsIwDNx5hdUVNQImBANsiIUFMSGG0KZqVUhD46ggxAN4A0sW-AAbP-nKS4gTBoiUu_jss-PbI-MJVrVtX6vlfDEbQSlqKXagBWoHByNkIjTsOebMyCKpUgGqFognVRcSYdw5QxRB1KPbI2QBvMC86vGr_B72F7n0hZrxUNYnOnoTeKfjqEuv2A8IPWnY5W4wi4dtvIbUKPpKU2BeGaQqbbZuiwnohiuK31cLXKawCaYnmqSEtdtPAYMNDLbFNGSsDfwB)
Returns `t` for falsey and `f` for truthy.
With zeros removed, is it a sub-sequence of `"."`? And is the original input not equal to `"."`?
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 75 bytes
```
i;f(char*s){return*s==48?i+=2,f(s+1):*s-46||i++&1?s=i!=1&!*s,i=0,s:f(s+1);}
```
[Try it online!](https://tio.run/##VYzdCoJAEIXv5ylMSHZdlTEkUll8kOpCzJ@FWsIxCtRn33brpoYZ@M7MmdPEfdMYo8qONUM9hsTnsZ0eow5JyuxQKSF3UcdIpLwIKc72y6KECNKKpNrINNiEFCmJERVfU7maW6004zO4PI@OeX4u4Tmoa8v6diJGnMN9VHrqmL@9nLQfeZ1blrAaBESExLXFxCo7H/6t5E8h1O6cAr4se9brgUCIbYj7TfAN "C (gcc) – Try It Online")
[Answer]
# [Go](https://go.dev), 106 bytes
```
import."regexp"
func f(s string)bool{return len(s)>0&&!MustCompile(`^(0+(\.0*)?|0*\.0+)$`).MatchString(s)}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=dVHdTsIwFI63fYpDFdLCWOadWYKGGLwSIQPjhairs8XpWJetIyTIk3hDTHwovPRJ7Nb5l0CTnp6e0_N953x9fZvK9aaVsOCZTTnMWBgjFM4SmSobi5nCP5dMpWE8zfB7rkT7aPP0HU_5lC8SjEQeByBIBuYhvZcyWqZc5WkMEY9JRo-dRqPWzzN1KmdJGHHi3xKnRSa206QnL05TOy164FO7z1TwOCphdNnKMH7sfZYUw18KMri-qdwlkuB2YJREoSKZhScxpkjIFO4s7nZSFuvhJCwH0AGWJDx-IAMLPJ5ELODdKCLc8rFv-T6lK2SaRitkZio0IRSWSLAo41lBMyQ-xgg7xXYKaxtTBuwyWtoq8nfZ_24O9ilCKs1_cZmpOCyORVkPJQho0yq8dsll4G0DUA1aQJhRq1YrVQThFIVCC1DrmJTOwFALpwTBPc8beC5cdS_GcNY9H_VcqO_PoT7XGlrALZBUa7HawmL63kZSZHZxjL3LXRTVV6_X5vwC)
Port of the reference regexp.
[Answer]
# [R](https://www.r-project.org), 36 bytes
```
\(s)trimws(s,,0)%in%c("",".")&s!="."
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72waMGiNNulpSVpuhY3VWI0ijVLijJzy4s1inV0DDRVM_NUkzWUlHSU9JQ01YoVbYE0VO2t5MQSDSW3xJzi1MqYPCVNrjSgOjBpAKUMoAw9OA2T0YOpgDEQUshAD4UHUsEFtjSkqLQkA25pIlynIZRVATctFcpQgAkoQGhtKF8X5jS4O0COhfhwwQIIDQA)
Port of [@Albert.Lang's answer](https://codegolf.stackexchange.com/a/256170/55372).
Uses the `whitespace` argument of the `trimws` function introduced in R 3.6.0.
[Answer]
# Regex (any), 16 bytes
```
^0*(0\.|\.0)?0*$
```
Falsy matches the regex, truthy doesn't.
# [Python 3](https://docs.python.org/3/), 46 bytes
```
import re;re.compile(r"0*(0\.|\.0)?0*$").match
```
[Try it online!](https://tio.run/##jZDBTsQgEEDv/YoJeihrl9DtraYaL1734sHE9YCVpiS0JYCNTfz3CkNN3OxBSZiBN4F5YBbfT2O1rmowk/Vg5W3XWMnaaTBKy9wSvsv5iX2dGKf3fHdNKBuEb/vV2w/fL9CAFsPbu4C5hnHy0OUzza7A8Rr4/s6VBbCQDgUcIy3PaLXRQ6IV0k4oXcBz5NUlP2bGqtHn5FFoJ5ea0KybLMxCgxrhhZCC8Dh5jCwFBAwpxo38Huxsx8lrnUEYwjkZPiU9NQ9NKDQNYGusJxcrjcUi3eRo9mP5hCcvLEXqX8b0iTaAShDCTVzt0TzJsj90Qo9/2jxoDV46D61w0oEJ9xG6fgM "Python 3 – Try It Online")
[Answer]
# [Pip](https://github.com/dloscutoff/pip), ~~16~~ 13 bytes
```
aRM0N'.&!aQ'.
```
[Try It Online!](https://dso.surge.sh/#@WyJwaXAiLCJGYVtcbltcIlwiXVxuW1wiMFwiXVxuW1wiMDAwXCJdXG5bXCIuMFwiXVxuW1wiLjAwXCJdXG5bXCIwLlwiXVxuW1wiMDAuXCJdXG5bXCIwLjAwXCJdXG5bXCIwMDAwMDAwMDAwMDAwLjAwMDAwMDAwMDAwMDAwXCJdXG5bXCJhXCJdXG5bXCIwMDAxXCJdXG5bXCIweDAwXCJdXG5bXCIwZTBcIl1cbltcIiAwXCJdXG5bXCIwIFwiXVxuW1wiKzBcIl1cbltcIi0wXCJdXG5bXCIuXCJdXG5bXCIwLjAuMFwiXVxuXXtcblAoKFNUYSlXUlxcXCJcIlxcXCIpLlwiIC0+IFwiLltcIkZhbHNlXCI7XCJUcnVlXCJdQHsiLCJhUk0wTicuJiFhUScuIiwifVZhXG59IiwiXCIuMDAwLjAwXCIiLCIiXQ==)
-3 bytes thanks to @DLosc  
Non-trivial pip answer, port of [@Albert.Lang's answer](https://codegolf.stackexchange.com/a/256170/110555)
[Answer]
# [Acc!!](https://www.python.org), 107 bytes
```
Count i while 1-_/4 {
_*524+N
53308230694/5^(_/131+2*0^(_%131-48)^2+0^(_%131-46)^2+_^130%131)%5+1
}
Write _
```
[Attempt This Online!](https://ato.pxeger.com/run?1=vVfbbuM2EH03-hEEA8OSFcl2LotsgPQl2LfCKLpF-5DEAivTMbsSKVDUxtkgX9KXvOz-U_sd_YDOkNKKXis3FC0B60IOzxmeGZOjP76Ut2at5MNf330SRam0IZrvk-q2GgyWfEV0LYNMLaFLyDI8HRBo-E7O7C2pylyYYHQpR6E_ZjSTVc4Mt5PdEN_wrMG6o4BWm_dGc1bQUxIovQyyNdMhWSlN8An4LOV96BzpEFmWnSOoc0bIJZcGKKf2NVeq_IXpCjourmxPeXvufLqgKZpR1408uZB8Xhf79gEJuawLrndJLNGK0D2KVmjd9WPbI7AUUcLqiwK8qbYGLfiZvV2c4jVBnzcBoIVXgx6rpEKwIPSppTI9vJmSRsiab6HAikh0Rmb-dId-Rug93UaAMafgdrcnJTrViJqUynerbU7hhJUll8uAEjpughJ9xYgItT7R3dmNbex7_AJkuuQ5grYU28A8r_juijQTFSfvb6Vhm3daKx3QH1CY4fKU1LJgJlvzJbmnZNgK2aHuIhagjObJqs5zOzXQ9FzV4FxwweJPVyG5WYuckyCJQnJ5R12Whd-qX-y6yTel5lUllASGjywXS8jId187gyK51qoug4OwR82VN30XGlsX1xZotovzjPp-XPE_9WoA6sTBAHrLhf7TR7DamX1p4q2qatl608Kq25sa2J5KDyFtIHxnvTTphdttEXksdP1O9WTYr1oYl1O9CWWV6k0qy_LCxJr1JFaD_FxyYXss7C9WiZZaSAMHgg6GVbgP2_LybDQKUfCOv9_Fx6OL7bURfqHH2F6bC26lTyn--FKei2N_XmD7lxHE2OAhuv23_a8iURlYFp6n_0MgOsk0N7WG2F9KmvyuhAycGE0Z0qM2CtHUCfTntkqprD7EKPKjra_8mEHl4UgqMldYeKzaJSe0qZRK3J7xtlULgCFsBxVn2u4FFwsyjd_CWZPOg3A8GS6i-Ap2Bc8fbHuk89UWDEwAcasxllosM1x3NUsjALrmvMm_5QXKeXp1eRO9lK2ocyNK2O9zbpALJagho3SVKTDGoooRrW6e8MFPpj0YMOQagnONCsOpnX1wkRHmlqgVYXlOBCasWImGTvLKoD2MlkxzWcWxhwd-EbPmbbBsFWvW4BFhEDrMTxS_1Oq3nBcVYRqzFyZo7oH8xMucZZxUayyjVYmVpAL2G2HWaCx0i_8RnAKBOs39iGsHE9AFyEvHY-9A7DWboNlk4pl1rswdOSMZSgJaXTcLlXxjiC3CuxR4mmaONF7ZDvkAewNGKPSom8Dh1MEAJEtTyQqeprb4TNMC0iFN6dZ3xGg0-lybVXzy5wdXP4mmcprF6eSI3A3S8fHBUTQfHB8eTk8ODqdv3h5NjhdBOpkdzqKD8RQeh_AYH52Ei4Ooe32Dr-lidjjF93B4HM0G9wN3gqYN5d_A3nxHwMrsZwOl-3SKvyleE3exHYnttdemx2_J1hsOM2cyw9vGTeB4JfaRwCXCp9hSONTE_z4Bn5rPIHCtS393OkLvvj0YSfw9GXkR8L_YotHl1BtzM0O39ocHd_8H)
Takes the input NULL-terminated, returns `chr(5)` for truthy and `chr(4)` for falsey.
`53308230694` encodes this table (minus 1, which is later added), which represents the transitions of a FSM for this language, and the rest of the code just converts the input to the correct format.
| State\Input | 0 | 1 | 2 | 3 |
| --- | --- | --- | --- | --- |
| 0 | 5 | 4 | 3 | 1 |
| 1 | 5 | 4 | 2 | 1 |
| 2 | 5 | 4 | 4 | 2 |
| 3 | 4 | 4 | 4 | 2 |
Where 0 is "null byte", 1 is "invalid character", 2 is ".", and 3 is "0". The state 4 is rejected, and 5 is accepted.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~73~~ ~~72~~ ~~67~~ ~~66~~ 64 bytes
```
lambda v:not re.match("^(0+(\.0*)?|0*\.0+)$",v)and""<v
import re
```
[Try it online!](https://tio.run/##jY7BagMhEIbvPsUw9KDZVCy9LV1KL32C3pIWbOKyC64rapcE8u4bHXNoKYUO@Dv@g/N//pyG2T2ufbdfrZ4@jxqW1s0JgpGTToeB4wdXDd9LtRHPF7XJTSPucLsI7Y6ITwsbJz@H8mH1YXSJ46u20ZxbFKyfAyzawuhgh7hFVY4qKquQIcklvTnfS/54KXxvGeTSMZqc2vO8X0DXAaXSqGIE4wMNBauGYLcG38JXGn4D6hr9UK4TgQDRQJamdPcEXTnl3yR5/T9BXqyFZGKCg44mgs@rUKxX "Python 3 – Try It Online")
Golfed reference implementation from @DLosc.
[Answer]
# [PowerShell Core](https://github.com/PowerShell/PowerShell), 31 bytes
```
"$args"-match"^0*(0\.|\.0)?0*$"
```
[Try it online!](https://tio.run/##dY7RTsMgFEDf@xWEENPOQfADFpss81XjfHNqEG9tls5OoHHJ1m@vICnp9HrfOPdwYN9@gbE1NA3XrYGBVYvjQJky75bynXK6ps9ylsuNOG2ELK7ljNGhz7Iyz4ifeZlTOiesUo2FIiGJMYlRgUM0INAqSv8pTEecnTBdBeZMd164Qugh3v9FAYEEE8lfdol4HGECyQkpJmZBTuSmNSula377ugXtyPHHZQ6s8xoc9h7CG1kQ9hI3BmzXOA/4R@vyC1ZFOb7xeLdedta1u1h7KmMuzLrTGqwNpVTl8DkGk/fgY0EK0QRXk3@Mt9PyfvzRNNVn/fAN "PowerShell Core – Try It Online")
Down to 31 bytes using [Bubbler's regex](https://codegolf.stackexchange.com/a/256389/97729)
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 8 bytes
```
x"0."_S{
```
[Try it online!](https://tio.run/##K6gsyfj/v0LJQE8pPrj6/38gw0AJAA "Pyth – Try It Online")
Feels like there's gotta be something shorter but I couldn't find it.
Outputs 0 for falsy and -1 or 1 for truthy.
### Explanation
```
x"0."_S{Q    # Implicitly add Q
             # Implicitly assign Q = eval(input())
       {Q    # deduplicate
      S      # sort
     _       # reverse (at this point we have either "", "0", or "0.")
x"0."        # find in "0." (returns 0 for above, 1 for ".", -1 for all else)
```
[Answer]
# Google Sheets, ~~37~~ 34 bytes
`=regexmatch(A1,"^0*\.?0*$")*(A1<>".")`
Put the input in cell `A1` and the formula in `B1`. Outputs `1` for falsey and `0` for truthy.
Using [Bubbler's](https://codegolf.stackexchange.com/a/256389/119296) regex:
`=regexmatch(A1,"^0*(0\.|\.0)?0*$")`
Outputs `TRUE` for falsey and `FALSE` for truthy.
[Answer]
# [Uiua](https://www.uiua.org/), ~~33 bytes~~ 28 bytes (SBCS)
Edit: Using [Bubbler's improved regex](https://codegolf.stackexchange.com/a/256389/97729).
```
=0⧻regex"^0*(0\\.|\\.0)?0*$"
```
[Try it online!](https://www.uiua.org/pad?src=UGlwIOKGkCA9MOKnu3JlZ2V4Il4wKigwXFwufFxcLjApPzAqJCIKCiJGYWxzZXkiClBpcCAiIgpQaXAgIjAiClBpcCAiMDAwIgpQaXAgIi4wIgpQaXAgIi4wMCIKUGlwICIwLiIKUGlwICIwMC4iClBpcCAiMC4wMCIKUGlwICIwMDAwMDAwMDAwMDAwLjAwMDAwMDAwMDAwMDAwIgoKIlRydXRoeSIKUGlwICJhIgpQaXAgIjAwMDEiClBpcCAiMHgwMCIKUGlwICIwZTAiClBpcCAiIDAiClBpcCAiMCAiClBpcCAiKzAiClBpcCAiLTAiClBpcCAiLiIKUGlwICIwLjAuMCIKUGlwICIwLi4wIgo=)
Not much to explain here - it just matches the regex with the input string and checks that the number of matches is 0.
# Idiomatic Uiua, 39 bytes
```
(0;|(↥⊃'>⊢(<⊢⇌)∶1|1;)∊0∩/+⍉.∺="0.")>0⧻.
```
[Try it online!](https://www.uiua.org/pad?src=UGlwIOKGkCAoMDt8KOKGpeKKgyc-4oqiKDziiqLih4wp4oi2MXwxOyniiIow4oipLyvijYku4oi6PSIwLiIpPjDip7suCgoiRmFsc2V5IgpQaXAgIiIKUGlwICIwIgpQaXAgIjAwMCIKUGlwICIuMCIKUGlwICIuMDAiClBpcCAiMC4iClBpcCAiMDAuIgpQaXAgIjAuMDAiClBpcCAiMDAwMDAwMDAwMDAwMC4wMDAwMDAwMDAwMDAwMCIKCiJUcnV0aHkiClBpcCAiYSIKUGlwICIwMDAxIgpQaXAgIjB4MDAiClBpcCAiMGUwIgpQaXAgIiAwIgpQaXAgIjAgIgpQaXAgIiswIgpQaXAgIi0wIgpQaXAgIi4iClBpcCAiMC4wLjAiCg==)
**Explanation:**
```
(0;|                                )>0⧻.   # If the length is 0 return 0. Otherwise:
                              ∺="0."        # Produce a matrix of matches with '0' and '.'
                           ⍉.              # Make a copy and transpose it
                        ∩/+                 # In both the original and transposed matrices, add up each row
    (             |1;)∊0                    # If there is a 0 in the per character array
                                            # (signifying a character other than '0' or '.'),
                                            # return 1. Otherwise:
                ∶1                          # Put a 1 on the stack and swap the top two items
      ⊃                                     # Apply both of the next functions to the same values
          (<⊢⇌)                            # Reverse the array and check if 1 < the first value
                                            # (This tests that the number of '.' chars is > 1)
       '>⊢                                  # Check if 1 > the first value
                                            # (This tests that the number of '0' chars is < 1)
     ↥                                      # Return the maximum of the two checks
# (This will return 0 if the number of '0' chars >= 1 AND the number of '.' <= 1)
```
[Answer]
# [Uiua](https://uiua.org), 18 [bytes](https://codegolf.stackexchange.com/a/265917/97916)
```
<∩≍¬⊚.=@.⊃▽'△.≠@0.
```
[Try it online!](https://www.uiua.org/pad?src=ZiDihpAgPOKIqeKJjcKs4oqaLj1ALuKKg-KWvSfilrMu4omgQDAuCgriipDiiLVmeyIiCiAgICAiMCIKICAgICIwMDAiCiAgICAiLjAiCiAgICAiLjAwIgogICAgIjAuIgogICAgIjAwLiIKICAgICIwLjAwIgogICAgIjAwMDAwMDAwMDAwMDAuMDAwMDAwMDAwMDAwMDAifQoK4oqQ4oi1ZnsiYSIKICAgICIwLi4wIgogICAgIjAwMDEiCiAgICAiMHgwMCIKICAgICIwZTAiCiAgICAiIDAiCiAgICAiMCAiCiAgICAiKzAiCiAgICAiLTAiCiAgICAiLiIKICAgICIwLjAuMCJ9Cg==)
Initially based on [chunes' Factor answer](https://codegolf.stackexchange.com/a/256185/78410), but it evolved a lot from it. Returns 1 if the input is falsy, 0 otherwise.
```
<∩≍¬⊚.=@.⊃▽'△.≠@0.    input: a string S
                  ≠@0.    keep S and push its non-zero-digit mask
          ⊃▽            S with zeros filtered out
       =@.                is-dot mask of above
 ∩≍¬⊚.                C1:is it the same as boolean negation of its nonzero indices?
(the length can be equal only if the mask is all ones, and the content equal only if
 the length is zero or one, i.e. the array is [] or [1].
 this tests if the input without zeros is either empty or a sole dot.
 now we need to filter out the case where S = ".")
 ∩≍       ⊃  '△.     C2:take the non-zero-digit mask, and test if it is the same
                          as its shape
(this test passes only if the array is [1])
<                         test if C1 is true and C2 is false
```
More explanation on the C1 condition:
The input is a boolean vector. `⊚` (where) on it collects the zero-based indices of ones, e.g. `[1, 0, 1, 1, 0, 0, 1]` becomes `[0, 2, 3, 6]`. The "logical negation" `¬` calculates `1-x` for each value `x` in the array, e.g. `[0, 2, 3, 6]` becomes `[1, -1, -2, -5]`.
For the input to equal its `¬⊚`, the following conditions need to be met:
* The lengths are equal. For a boolean vector input, `⊚` generates a vector whose length is the count of ones in the input. To meet the length requirement, the input vector must be all ones.
* The individual values are equal. Since the input is boolean, the output must be also boolean (either 0 or 1). `¬` maps 2 or higher to negative numbers, so the original input cannot contain a 1 at indices 2 or higher. This reduces the candidates to `[]`, `[1]`, and `[1,1]`.
Now we can do an exhaustive check:
```
input -> ⊚ -> ¬⊚
[] -> [] -> []
[1] -> [0] -> [1]
[1,1] -> [0,1] -> [1,0]
```
Therefore `≍¬⊚.` checks if the given boolean vector is either `[]` or `[1]`.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 15 bytes
```
s=>-s!=0+s+'e0'
```
[Try it online!](https://tio.run/##VYyxDsIwDER3f0WYkqiqZeYq3fgLhkYlgaLSVHGE@vfBYQLLlt7pzvf0b89zXvbSb@kWanSV3djzyVHHnQ6ka1FOTUBARIBtBVGU3Jd/B/8UgW/2GegQVpJVQIGgI@ilqP1L4QEJJix5eRmLvK9LMfq6aTtAwZjyxc8Pw8qNak4bpzXgmu4mGrbWDvUD "JavaScript (Node.js) – Try It Online")
* If `s` is number, then `s==0` to make it false. `e0` avoids another `e` in number(`0e0`).
* If `s` is `.`, `x` or `o`, then `-s` is `NaN`
* If `s` is  `0` or `0` , then `0+s+0` is NaN
Assumes double handle enough logrange
]